void CPVRGUIInfo::UpdateTimeshift(void)
{
bool bStarted = g_PVRManager.IsStarted();
bool bIsTimeshifting = bStarted && g_PVRClients->IsTimeshifting();
CDateTime tmp;
time_t iTimeshiftStartTime = g_PVRClients->GetBufferTimeStart();
tmp.SetFromUTCDateTime(iTimeshiftStartTime);
std::string strTimeshiftStartTime = tmp.GetAsLocalizedTime("", false);
time_t iTimeshiftEndTime = g_PVRClients->GetBufferTimeEnd();
tmp.SetFromUTCDateTime(iTimeshiftEndTime);
std::string strTimeshiftEndTime = tmp.GetAsLocalizedTime("", false);
time_t iTimeshiftPlayTime = g_PVRClients->GetPlayingTime();
tmp.SetFromUTCDateTime(iTimeshiftPlayTime);
std::string strTimeshiftPlayTime = tmp.GetAsLocalizedTime("", true);
CSingleLock lock(m_critSection);
m_bIsTimeshifting = bIsTimeshifting;
m_iTimeshiftStartTime = iTimeshiftStartTime;
m_iTimeshiftEndTime = iTimeshiftEndTime;
m_iTimeshiftPlayTime = iTimeshiftPlayTime;
m_strTimeshiftStartTime = strTimeshiftStartTime;
m_strTimeshiftEndTime = strTimeshiftEndTime;
m_strTimeshiftPlayTime = strTimeshiftPlayTime;
}
CStdString CGUIDialogMediaFilter::RangeAsTime(float valueLower, float valueUpper, float minimum)
{
CDateTime from = (time_t)valueLower;
CDateTime to = (time_t)valueUpper;
CStdString text;
if (valueLower != valueUpper)
text.Format(g_localizeStrings.Get(21469).c_str(), from.GetAsLocalizedTime("mm:ss"), to.GetAsLocalizedTime("mm:ss"));
else
text.Format("%s", from.GetAsLocalizedTime("mm:ss"));
return text;
}
void CProfile::setDate()
{
const CDateTime now = CDateTime::GetCurrentDateTime();
std::string strDate = now.GetAsLocalizedDate(false);
std::string strTime = now.GetAsLocalizedTime(TIME_FORMAT_GUESS);
if (strDate.empty() || strTime.empty())
setDate("-");
else
setDate(strDate+" - "+strTime);
}
bool CMythDirectory::GetGuideForChannel(const CStdString& base, CFileItemList &items, int channelNumber)
{
cmyth_database_t database = m_session->GetDatabase();
if (!database)
{
CLog::Log(LOGERROR, "%s - Could not get database", __FUNCTION__);
return false;
}
time_t now;
time(&now);
time_t end = now + (24 * 60 * 60); // How many seconds of EPG from now we should grab, 24 hours in seconds
cmyth_program_t *program = NULL;
// TODO: See if there is a way to just get the entries for the chosen channel rather than ALL
int count = m_dll->mysql_get_guide(database, &program, now, end);
CLog::Log(LOGDEBUG, "%s - %i entries in guide data", __FUNCTION__, count);
if (count <= 0)
return false;
for (int i = 0; i < count; i++)
{
if (program[i].channum == channelNumber)
{
CFileItemPtr item(new CFileItem("", false)); // No path for guide entries
/*
* Set the FileItem meta data.
*/
CStdString title = program[i].title; // e.g. Mythbusters
CStdString subtitle = program[i].subtitle; // e.g. The Pirate Special
CDateTime localstart;
if (program[i].starttime)
localstart = CTimeUtils::GetLocalTime(program[i].starttime);
item->m_strTitle = StringUtils::Format("%s - %s",
localstart.GetAsLocalizedTime("HH:mm", false).c_str(),
title.c_str()); // e.g. 20:30 - Mythbusters
if (!subtitle.empty())
item->m_strTitle += " - \"" + subtitle + "\""; // e.g. 20:30 - Mythbusters - "The Pirate Special"
item->m_dateTime = localstart;
/*
* Set the VideoInfoTag meta data so it matches the FileItem meta data where possible.
*/
CVideoInfoTag* tag = item->GetVideoInfoTag();
tag->m_strTitle = title;
if (!subtitle.empty())
tag->m_strTitle += " - \"" + subtitle + "\""; // e.g. Mythbusters - "The Pirate Special"
tag->m_strShowTitle = title;
tag->m_strOriginalTitle = title;
tag->m_strPlotOutline = subtitle;
tag->m_strPlot = program[i].description;
// TODO: Strip out the subtitle from the description if it is present at the start?
// TODO: Do we need to add the subtitle to the start of the plot if not already as it used to? Seems strange, should be handled by skin?
tag->m_genre = StringUtils::Split(program[i].category, g_advancedSettings.m_videoItemSeparator); // e.g. Sports
tag->m_strAlbum = program[i].callsign; // e.g. TV3
CDateTime start(program[i].starttime);
CDateTime end(program[i].endtime);
CDateTimeSpan runtime = end - start;
tag->m_duration = runtime.GetSeconds() + runtime.GetMinutes() * 60 + runtime.GetHours() * 3600;
tag->m_iSeason = 0; // So XBMC treats the content as an episode and displays tag information.
tag->m_iEpisode = 0;
items.Add(item);
}
}
/*
* Items are sorted as added to the list (in ascending date order). Specifying sorting by date can
* result in the guide being shown in the wrong order for skins that sort by date in descending
* order by default with no option to change to ascending, e.g. Confluence.
*/
items.AddSortMethod(SortByNone, 552 /* Date */, LABEL_MASKS("%K", "%J")); // Still leave the date label
m_dll->ref_release(program);
return true;
}
void CGUIEPGGridContainerModel::Initialize(const std::unique_ptr<CFileItemList> &items, const CDateTime &gridStart, const CDateTime &gridEnd, int iRulerUnit, int iBlocksPerPage, float fBlockSize)
{
if (!m_channelItems.empty())
{
CLog::LogF(LOGERROR, "Already initialized!");
return;
}
////////////////////////////////////////////////////////////////////////
// Create programme & channel items
m_programmeItems.reserve(items->Size());
CFileItemPtr fileItem;
int iLastChannelID = -1;
ItemsPtr itemsPointer;
itemsPointer.start = 0;
CPVRChannelPtr channel;
int j = 0;
for (int i = 0; i < items->Size(); ++i)
{
fileItem = items->Get(i);
if (!fileItem->HasEPGInfoTag() || !fileItem->GetEPGInfoTag()->HasChannel())
continue;
m_programmeItems.emplace_back(fileItem);
channel = fileItem->GetEPGInfoTag()->Channel();
if (!channel)
continue;
int iCurrentChannelID = channel->ChannelID();
if (iCurrentChannelID != iLastChannelID)
{
if (j > 0)
{
itemsPointer.stop = j - 1;
m_epgItemsPtr.emplace_back(itemsPointer);
itemsPointer.start = j;
}
iLastChannelID = iCurrentChannelID;
m_channelItems.emplace_back(CFileItemPtr(new CFileItem(channel)));
}
++j;
}
if (!m_programmeItems.empty())
{
itemsPointer.stop = m_programmeItems.size() - 1;
m_epgItemsPtr.emplace_back(itemsPointer);
}
/* check for invalid start and end time */
if (gridStart >= gridEnd)
{
// default to start "now minus GRID_START_PADDING minutes" and end "start plus one page".
m_gridStart = CDateTime::GetUTCDateTime() - CDateTimeSpan(0, 0, GetGridStartPadding(), 0);
m_gridEnd = m_gridStart + CDateTimeSpan(0, 0, iBlocksPerPage * MINSPERBLOCK, 0);
}
else if (gridStart > (CDateTime::GetUTCDateTime() - CDateTimeSpan(0, 0, GetGridStartPadding(), 0)))
{
// adjust to start "now minus GRID_START_PADDING minutes".
m_gridStart = CDateTime::GetUTCDateTime() - CDateTimeSpan(0, 0, GetGridStartPadding(), 0);
m_gridEnd = gridEnd;
}
else
{
m_gridStart = gridStart;
m_gridEnd = gridEnd;
}
// roundup
m_gridStart = CDateTime(m_gridStart.GetYear(), m_gridStart.GetMonth(), m_gridStart.GetDay(), m_gridStart.GetHour(), m_gridStart.GetMinute() >= 30 ? 30 : 0, 0);
m_gridEnd = CDateTime(m_gridEnd.GetYear(), m_gridEnd.GetMonth(), m_gridEnd.GetDay(), m_gridEnd.GetHour(), m_gridEnd.GetMinute() >= 30 ? 30 : 0, 0);
////////////////////////////////////////////////////////////////////////
// Create ruler items
CDateTime ruler;
ruler.SetFromUTCDateTime(m_gridStart);
CDateTime rulerEnd;
rulerEnd.SetFromUTCDateTime(m_gridEnd);
CFileItemPtr rulerItem(new CFileItem(ruler.GetAsLocalizedDate(true)));
rulerItem->SetProperty("DateLabel", true);
m_rulerItems.emplace_back(rulerItem);
const CDateTimeSpan unit(0, 0, iRulerUnit * MINSPERBLOCK, 0);
for (; ruler < rulerEnd; ruler += unit)
{
rulerItem.reset(new CFileItem(ruler.GetAsLocalizedTime("", false)));
rulerItem->SetLabel2(ruler.GetAsLocalizedDate(true));
m_rulerItems.emplace_back(rulerItem);
}
FreeItemsMemory();
////////////////////////////////////////////////////////////////////////
// Create epg grid
const CDateTimeSpan blockDuration(0, 0, MINSPERBLOCK, 0);
const CDateTimeSpan gridDuration(m_gridEnd - m_gridStart);
m_blocks = (gridDuration.GetDays() * 24 * 60 + gridDuration.GetHours() * 60 + gridDuration.GetMinutes()) / MINSPERBLOCK;
if (m_blocks >= MAXBLOCKS)
m_blocks = MAXBLOCKS;
else if (m_blocks < iBlocksPerPage)
m_blocks = iBlocksPerPage;
m_gridIndex.reserve(m_channelItems.size());
const std::vector<GridItem> blocks(m_blocks);
for (size_t channel = 0; channel < m_channelItems.size(); ++channel)
{
m_gridIndex.emplace_back(blocks);
CDateTime gridCursor(m_gridStart); //reset cursor for new channel
unsigned long progIdx = m_epgItemsPtr[channel].start;
unsigned long lastIdx = m_epgItemsPtr[channel].stop;
int iEpgId = m_programmeItems[progIdx]->GetEPGInfoTag()->EpgID();
int itemSize = 1; // size of the programme in blocks
int savedBlock = 0;
CFileItemPtr item;
CPVREpgInfoTagPtr tag;
for (int block = 0; block < m_blocks; ++block)
{
while (progIdx <= lastIdx)
{
item = m_programmeItems[progIdx];
tag = item->GetEPGInfoTag();
// Note: Start block of an event is start-time-based calculated block + 1,
// unless start times matches exactly the begin of a block.
if (tag->EpgID() != iEpgId || gridCursor < tag->StartAsUTC() || m_gridEnd <= tag->StartAsUTC())
break;
if (gridCursor < tag->EndAsUTC())
{
m_gridIndex[channel][block].item = item;
m_gridIndex[channel][block].progIndex = progIdx;
break;
}
progIdx++;
}
gridCursor += blockDuration;
if (block == 0)
continue;
const CFileItemPtr prevItem(m_gridIndex[channel][block - 1].item);
const CFileItemPtr currItem(m_gridIndex[channel][block].item);
if (block == m_blocks - 1 || prevItem != currItem)
{
// special handling for last block.
int blockDelta = -1;
int sizeDelta = 0;
if (block == m_blocks - 1 && prevItem == currItem)
{
itemSize++;
blockDelta = 0;
sizeDelta = 1;
}
if (prevItem)
{
m_gridIndex[channel][savedBlock].item->SetProperty("GenreType", prevItem->GetEPGInfoTag()->GenreType());
}
else
{
CPVREpgInfoTagPtr gapTag(CPVREpgInfoTag::CreateDefaultTag());
gapTag->SetChannel(m_channelItems[channel]->GetPVRChannelInfoTag());
CFileItemPtr gapItem(new CFileItem(gapTag));
for (int i = block + blockDelta; i >= block - itemSize + sizeDelta; --i)
{
m_gridIndex[channel][i].item = gapItem;
}
}
float fItemWidth = itemSize * fBlockSize;
m_gridIndex[channel][savedBlock].originWidth = fItemWidth;
m_gridIndex[channel][savedBlock].width = fItemWidth;
itemSize = 1;
savedBlock = block;
// special handling for last block.
if (block == m_blocks - 1 && prevItem != currItem)
{
if (currItem)
{
m_gridIndex[channel][savedBlock].item->SetProperty("GenreType", currItem->GetEPGInfoTag()->GenreType());
}
else
{
CPVREpgInfoTagPtr gapTag(CPVREpgInfoTag::CreateDefaultTag());
gapTag->SetChannel(m_channelItems[channel]->GetPVRChannelInfoTag());
CFileItemPtr gapItem(new CFileItem(gapTag));
m_gridIndex[channel][block].item = gapItem;
}
m_gridIndex[channel][savedBlock].originWidth = fBlockSize; // size always 1 block here
m_gridIndex[channel][savedBlock].width = fBlockSize;
}
}
else
{
itemSize++;
}
}
}
}
void CGUIEditControl::OnClick()
{
// we received a click - it's not from the keyboard, so pop up the virtual keyboard, unless
// that is where we reside!
if (GetParentID() == WINDOW_DIALOG_KEYBOARD)
return;
std::string utf8;
g_charsetConverter.wToUTF8(m_text2, utf8);
bool textChanged = false;
std::string heading = g_localizeStrings.Get(m_inputHeading ? m_inputHeading : 16028);
switch (m_inputType)
{
case INPUT_TYPE_READONLY:
textChanged = false;
break;
case INPUT_TYPE_NUMBER:
textChanged = CGUIDialogNumeric::ShowAndGetNumber(utf8, heading);
break;
case INPUT_TYPE_SECONDS:
textChanged = CGUIDialogNumeric::ShowAndGetSeconds(utf8, g_localizeStrings.Get(21420));
break;
case INPUT_TYPE_TIME:
{
CDateTime dateTime;
dateTime.SetFromDBTime(utf8);
SYSTEMTIME time;
dateTime.GetAsSystemTime(time);
if (CGUIDialogNumeric::ShowAndGetTime(time, !heading.empty() ? heading : g_localizeStrings.Get(21420)))
{
dateTime = CDateTime(time);
utf8 = dateTime.GetAsLocalizedTime("", false);
textChanged = true;
}
break;
}
case INPUT_TYPE_DATE:
{
CDateTime dateTime;
dateTime.SetFromDBDate(utf8);
if (dateTime < CDateTime(2000,1, 1, 0, 0, 0))
dateTime = CDateTime(2000, 1, 1, 0, 0, 0);
SYSTEMTIME date;
dateTime.GetAsSystemTime(date);
if (CGUIDialogNumeric::ShowAndGetDate(date, !heading.empty() ? heading : g_localizeStrings.Get(21420)))
{
dateTime = CDateTime(date);
utf8 = dateTime.GetAsDBDate();
textChanged = true;
}
break;
}
case INPUT_TYPE_IPADDRESS:
textChanged = CGUIDialogNumeric::ShowAndGetIPAddress(utf8, heading);
break;
case INPUT_TYPE_SEARCH:
textChanged = CGUIKeyboardFactory::ShowAndGetFilter(utf8, true);
break;
case INPUT_TYPE_FILTER:
textChanged = CGUIKeyboardFactory::ShowAndGetFilter(utf8, false);
break;
case INPUT_TYPE_PASSWORD_NUMBER_VERIFY_NEW:
textChanged = CGUIDialogNumeric::ShowAndVerifyNewPassword(utf8);
break;
case INPUT_TYPE_PASSWORD_MD5:
utf8 = ""; // TODO: Ideally we'd send this to the keyboard and tell the keyboard we have this type of input
// fallthrough
case INPUT_TYPE_TEXT:
default:
textChanged = CGUIKeyboardFactory::ShowAndGetInput(utf8, heading, true, m_inputType == INPUT_TYPE_PASSWORD || m_inputType == INPUT_TYPE_PASSWORD_MD5);
break;
}
if (textChanged)
{
ClearMD5();
m_edit.clear();
g_charsetConverter.utf8ToW(utf8, m_text2);
m_cursorPos = m_text2.size();
UpdateText();
m_cursorPos = m_text2.size();
}
}
bool CPlayerGUIInfo::GetLabel(std::string& value, const CFileItem *item, int contextWindow, const CGUIInfo &info, std::string *fallback) const
{
switch (info.m_info)
{
///////////////////////////////////////////////////////////////////////////////////////////////
// PLAYER_*
///////////////////////////////////////////////////////////////////////////////////////////////
case PLAYER_SEEKOFFSET:
{
std::string seekOffset = StringUtils::SecondsToTimeString(std::abs(m_seekOffset / 1000), static_cast<TIME_FORMAT>(info.GetData1()));
if (m_seekOffset < 0)
value = "-" + seekOffset;
else if (m_seekOffset > 0)
value = "+" + seekOffset;
return true;
}
case PLAYER_VOLUME:
value = StringUtils::Format("%2.1f dB", CAEUtil::PercentToGain(g_application.GetVolume(false)));
return true;
case PLAYER_SUBTITLE_DELAY:
value = StringUtils::Format("%2.3f s", g_application.GetAppPlayer().GetVideoSettings().m_SubtitleDelay);
return true;
case PLAYER_AUDIO_DELAY:
value = StringUtils::Format("%2.3f s", g_application.GetAppPlayer().GetVideoSettings().m_AudioDelay);
return true;
case PLAYER_CHAPTER:
value = StringUtils::Format("%02d", g_application.GetAppPlayer().GetChapter());
return true;
case PLAYER_CHAPTERCOUNT:
value = StringUtils::Format("%02d", g_application.GetAppPlayer().GetChapterCount());
return true;
case PLAYER_CHAPTERNAME:
g_application.GetAppPlayer().GetChapterName(value);
return true;
case PLAYER_PATH:
case PLAYER_FILENAME:
case PLAYER_FILEPATH:
value = item->GetPath();
if (info.m_info == PLAYER_PATH)
{
// do this twice since we want the path outside the archive if this
// is to be of use.
if (URIUtils::IsInArchive(value))
value = URIUtils::GetParentPath(value);
value = URIUtils::GetParentPath(value);
}
else if (info.m_info == PLAYER_FILENAME)
value = URIUtils::GetFileName(value);
return true;
case PLAYER_TITLE:
// use label or drop down to title from path
value = item->GetLabel();
if (value.empty())
value = CUtil::GetTitleFromPath(item->GetPath());
return true;
case PLAYER_PLAYSPEED:
{
float speed = g_application.GetAppPlayer().GetPlaySpeed();
if (speed == 1.0)
speed = g_application.GetAppPlayer().GetPlayTempo();
value = StringUtils::Format("%.2f", speed);
return true;
}
case PLAYER_TIME:
value = GetCurrentPlayTime(static_cast<TIME_FORMAT>(info.GetData1()));
return true;
case PLAYER_START_TIME:
{
const CDateTime time(g_application.GetAppPlayer().GetStartTime());
value = time.GetAsLocalizedTime(static_cast<TIME_FORMAT>(info.GetData1()));
return true;
}
case PLAYER_DURATION:
value = GetDuration(static_cast<TIME_FORMAT>(info.GetData1()));
return true;
case PLAYER_TIME_REMAINING:
value = GetCurrentPlayTimeRemaining(static_cast<TIME_FORMAT>(info.GetData1()));
return true;
case PLAYER_FINISH_TIME:
{
CDateTime time(CDateTime::GetCurrentDateTime());
int playTimeRemaining = GetPlayTimeRemaining();
float speed = g_application.GetAppPlayer().GetPlaySpeed();
float tempo = g_application.GetAppPlayer().GetPlayTempo();
if (speed == 1.0)
playTimeRemaining /= tempo;
time += CDateTimeSpan(0, 0, 0, playTimeRemaining);
value = time.GetAsLocalizedTime(static_cast<TIME_FORMAT>(info.GetData1()));
return true;
}
case PLAYER_TIME_SPEED:
{
float speed = g_application.GetAppPlayer().GetPlaySpeed();
if (speed != 1.0)
value = StringUtils::Format("%s (%ix)", GetCurrentPlayTime(static_cast<TIME_FORMAT>(info.GetData1())).c_str(), static_cast<int>(speed));
else
value = GetCurrentPlayTime(TIME_FORMAT_GUESS);
return true;
}
case PLAYER_SEEKTIME:
value = GetCurrentSeekTime(static_cast<TIME_FORMAT>(info.GetData1()));
return true;
case PLAYER_SEEKSTEPSIZE:
{
int seekSize = g_application.GetAppPlayer().GetSeekHandler().GetSeekSize();
std::string strSeekSize = StringUtils::SecondsToTimeString(abs(seekSize), static_cast<TIME_FORMAT>(info.GetData1()));
if (seekSize < 0)
value = "-" + strSeekSize;
if (seekSize > 0)
value = "+" + strSeekSize;
return true;
}
case PLAYER_SEEKNUMERIC:
value = GetSeekTime(static_cast<TIME_FORMAT>(info.GetData1()));
return !value.empty();
case PLAYER_CACHELEVEL:
{
int iLevel = g_application.GetAppPlayer().GetCacheLevel();
if (iLevel >= 0)
{
value = StringUtils::Format("%i", iLevel);
return true;
}
break;
}
case PLAYER_ITEM_ART:
value = item->GetArt(info.GetData3());
return true;
///////////////////////////////////////////////////////////////////////////////////////////////
// PLAYER_PROCESS_*
///////////////////////////////////////////////////////////////////////////////////////////////
case PLAYER_PROCESS_VIDEODECODER:
value = CServiceBroker::GetDataCacheCore().GetVideoDecoderName();
return true;
case PLAYER_PROCESS_DEINTMETHOD:
value = CServiceBroker::GetDataCacheCore().GetVideoDeintMethod();
return true;
case PLAYER_PROCESS_PIXELFORMAT:
value = CServiceBroker::GetDataCacheCore().GetVideoPixelFormat();
return true;
case PLAYER_PROCESS_VIDEOFPS:
value = StringUtils::Format("%.3f", CServiceBroker::GetDataCacheCore().GetVideoFps());
return true;
case PLAYER_PROCESS_VIDEODAR:
value = StringUtils::Format("%.2f", CServiceBroker::GetDataCacheCore().GetVideoDAR());
return true;
case PLAYER_PROCESS_VIDEOWIDTH:
value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetVideoWidth());
return true;
case PLAYER_PROCESS_VIDEOHEIGHT:
value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetVideoHeight());
return true;
case PLAYER_PROCESS_AUDIODECODER:
value = CServiceBroker::GetDataCacheCore().GetAudioDecoderName();
return true;
case PLAYER_PROCESS_AUDIOCHANNELS:
value = CServiceBroker::GetDataCacheCore().GetAudioChannels();
return true;
case PLAYER_PROCESS_AUDIOSAMPLERATE:
value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetAudioSampleRate());
return true;
case PLAYER_PROCESS_AUDIOBITSPERSAMPLE:
value = StringUtils::FormatNumber(CServiceBroker::GetDataCacheCore().GetAudioBitsPerSample());
return true;
///////////////////////////////////////////////////////////////////////////////////////////////
// PLAYLIST_*
///////////////////////////////////////////////////////////////////////////////////////////////
case PLAYLIST_LENGTH:
case PLAYLIST_POSITION:
case PLAYLIST_RANDOM:
case PLAYLIST_REPEAT:
value = GUIINFO::GetPlaylistLabel(info.m_info, info.GetData1());
return true;
}
return false;
}
void CGUIControlRangeSetting::Update(bool updateDisplayOnly /* = false */)
{
if (m_pSlider == NULL ||
m_pSetting->GetType() != SettingTypeList)
return;
CGUIControlBaseSetting::Update();
CSettingList *settingList = static_cast<CSettingList*>(m_pSetting);
const SettingPtrList &settingListValues = settingList->GetValue();
if (settingListValues.size() != 2)
return;
const CSetting *listDefintion = settingList->GetDefinition();
const CSettingControlRange *controlRange = static_cast<const CSettingControlRange*>(m_pSetting->GetControl());
const std::string &controlFormat = controlRange->GetFormat();
std::string strText;
std::string strTextLower, strTextUpper;
std::string formatString = g_localizeStrings.Get(controlRange->GetFormatLabel() > -1 ? controlRange->GetFormatLabel() : 21469);
std::string valueFormat = controlRange->GetValueFormat();
if (controlRange->GetValueFormatLabel() > -1)
valueFormat = g_localizeStrings.Get(controlRange->GetValueFormatLabel());
switch (listDefintion->GetType())
{
case SettingTypeInteger:
{
int valueLower, valueUpper;
if (updateDisplayOnly)
{
valueLower = m_pSlider->GetIntValue(CGUISliderControl::RangeSelectorLower);
valueUpper = m_pSlider->GetIntValue(CGUISliderControl::RangeSelectorUpper);
}
else
{
valueLower = static_cast<CSettingInt*>(settingListValues[0].get())->GetValue();
valueUpper = static_cast<CSettingInt*>(settingListValues[1].get())->GetValue();
m_pSlider->SetIntValue(valueLower, CGUISliderControl::RangeSelectorLower);
m_pSlider->SetIntValue(valueUpper, CGUISliderControl::RangeSelectorUpper);
}
if (controlFormat == "date" || controlFormat == "time")
{
CDateTime dateLower = (time_t)valueLower;
CDateTime dateUpper = (time_t)valueUpper;
if (controlFormat == "date")
{
if (valueFormat.empty())
{
strTextLower = dateLower.GetAsLocalizedDate();
strTextUpper = dateUpper.GetAsLocalizedDate();
}
else
{
strTextLower = dateLower.GetAsLocalizedDate(valueFormat);
strTextUpper = dateUpper.GetAsLocalizedDate(valueFormat);
}
}
else
{
if (valueFormat.empty())
valueFormat = "mm:ss";
strTextLower = dateLower.GetAsLocalizedTime(valueFormat);
strTextUpper = dateUpper.GetAsLocalizedTime(valueFormat);
}
}
else
{
strTextLower = StringUtils::Format(valueFormat.c_str(), valueLower);
strTextUpper = StringUtils::Format(valueFormat.c_str(), valueUpper);
}
if (valueLower != valueUpper)
strText = StringUtils::Format(formatString.c_str(), strTextLower.c_str(), strTextUpper.c_str());
else
strText = strTextLower;
break;
}
case SettingTypeNumber:
{
double valueLower, valueUpper;
if (updateDisplayOnly)
{
valueLower = static_cast<double>(m_pSlider->GetFloatValue(CGUISliderControl::RangeSelectorLower));
valueUpper = static_cast<double>(m_pSlider->GetFloatValue(CGUISliderControl::RangeSelectorUpper));
}
else
{
valueLower = static_cast<CSettingNumber*>(settingListValues[0].get())->GetValue();
valueUpper = static_cast<CSettingNumber*>(settingListValues[1].get())->GetValue();
m_pSlider->SetFloatValue((float)valueLower, CGUISliderControl::RangeSelectorLower);
m_pSlider->SetFloatValue((float)valueUpper, CGUISliderControl::RangeSelectorUpper);
}
strTextLower = StringUtils::Format(valueFormat.c_str(), valueLower);
if (valueLower != valueUpper)
{
strTextUpper = StringUtils::Format(valueFormat.c_str(), valueUpper);
strText = StringUtils::Format(formatString.c_str(), strTextLower.c_str(), strTextUpper.c_str());
}
else
strText = strTextLower;
break;
}
default:
strText.clear();
break;
}
if (!strText.empty())
m_pSlider->SetTextValue(strText);
}
static std::string ToSettingTimeFormat(const CDateTime& time, const std::string& timeFormat)
{
return StringUtils::Format(g_localizeStrings.Get(20036).c_str(), time.GetAsLocalizedTime(timeFormat, true).c_str(), timeFormat.c_str());
}
void CGUIDialogPVRGuideSearch::Update()
{
CGUISpinControlEx *pSpin;
CGUIEditControl *pEdit;
CGUIRadioButtonControl *pRadioButton;
if (!m_searchfilter)
return;
pEdit = (CGUIEditControl *)GetControl(CONTROL_EDIT_SEARCH);
if (pEdit)
{
pEdit->SetLabel2(m_searchfilter->m_strSearchTerm);
pEdit->SetInputType(CGUIEditControl::INPUT_TYPE_TEXT, 16017);
}
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_BTN_CASE_SENS);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bIsCaseSensitive);
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_BTN_INC_DESC);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bSearchInDescription);
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_BTN_FTA_ONLY);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bFTAOnly);
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_BTN_UNK_GENRE);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bIncludeUnknownGenres);
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_BTN_IGNORE_REC);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bIgnorePresentRecordings);
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_BTN_IGNORE_TMR);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bIgnorePresentTimers);
pRadioButton = (CGUIRadioButtonControl *)GetControl(CONTROL_SPIN_NO_REPEATS);
if (pRadioButton) pRadioButton->SetSelected(m_searchfilter->m_bPreventRepeats);
/* Set duration list spin */
pSpin = (CGUISpinControlEx *)GetControl(CONTROL_SPIN_MIN_DURATION);
if (pSpin)
{
pSpin->Clear();
pSpin->AddLabel("-", -1);
for (int i = 1; i < 12*60/5; i++)
{
CStdString string;
string.Format(g_localizeStrings.Get(14044),i*5);
pSpin->AddLabel(string, i*5);
}
pSpin->SetValue(m_searchfilter->m_iMinimumDuration);
}
pSpin = (CGUISpinControlEx *)GetControl(CONTROL_SPIN_MAX_DURATION);
if (pSpin)
{
pSpin->Clear();
pSpin->AddLabel("-", -1);
for (int i = 1; i < 12*60/5; i++)
{
CStdString string;
string.Format(g_localizeStrings.Get(14044),i*5);
pSpin->AddLabel(string, i*5);
}
pSpin->SetValue(m_searchfilter->m_iMaximumDuration);
}
/* Set time fields */
pEdit = (CGUIEditControl *)GetControl(CONTROL_EDIT_START_TIME);
if (pEdit)
{
CDateTime time = m_searchfilter->m_startTime;
pEdit->SetLabel2(time.GetAsLocalizedTime("", false));
pEdit->SetInputType(CGUIEditControl::INPUT_TYPE_TIME, 14066);
}
pEdit = (CGUIEditControl *)GetControl(CONTROL_EDIT_STOP_TIME);
if (pEdit)
{
CDateTime time = m_searchfilter->m_endTime;
pEdit->SetLabel2(time.GetAsLocalizedTime("", false));
pEdit->SetInputType(CGUIEditControl::INPUT_TYPE_TIME, 14066);
}
pEdit = (CGUIEditControl *)GetControl(CONTROL_EDIT_START_DATE);
if (pEdit)
{
CDateTime date = m_searchfilter->m_startDate;
pEdit->SetLabel2(date.GetAsDBDate());
pEdit->SetInputType(CGUIEditControl::INPUT_TYPE_DATE, 14067);
}
pEdit = (CGUIEditControl *)GetControl(CONTROL_EDIT_STOP_DATE);
if (pEdit)
{
CDateTime date = m_searchfilter->m_endDate;
pEdit->SetLabel2(date.GetAsDBDate());
pEdit->SetInputType(CGUIEditControl::INPUT_TYPE_DATE, 14067);
}
/* Set Channel list spin */
pSpin = (CGUISpinControlEx *)GetControl(CONTROL_SPIN_CHANNELS);
if (pSpin)
{
CFileItemList channelslist_tv;
const CPVRChannelGroup *group = CPVRManager::GetChannelGroups()->GetById(false, m_searchfilter->m_iChannelGroup);
if (group)
group->GetMembers(&channelslist_tv);
pSpin->Clear();
pSpin->AddLabel(g_localizeStrings.Get(19217), -1);
pSpin->AddLabel(g_localizeStrings.Get(19023), -2);
pSpin->AddLabel(g_localizeStrings.Get(19024), -3);
for (int i = 0; i < channelslist_tv.Size(); i++)
{
int chanNumber = channelslist_tv[i]->GetPVRChannelInfoTag()->ChannelNumber();
CStdString string;
string.Format("%i %s", chanNumber, channelslist_tv[i]->GetPVRChannelInfoTag()->ChannelName().c_str());
pSpin->AddLabel(string, chanNumber);
}
pSpin->SetValue(m_searchfilter->m_iChannelNumber);
}
/* Set Group list spin */
pSpin = (CGUISpinControlEx *)GetControl(CONTROL_SPIN_GROUPS);
if (pSpin)
{
CFileItemList grouplist;
CPVRManager::GetChannelGroups()->GetTV()->GetGroupList(&grouplist);
pSpin->Clear();
pSpin->AddLabel(g_localizeStrings.Get(593), -1);
for (int i = 0; i < grouplist.Size(); i++)
pSpin->AddLabel(grouplist[i]->GetLabel(), atoi(grouplist[i]->m_strPath));
pSpin->SetValue(m_searchfilter->m_iChannelGroup);
}
/* Set Genre list spin */
pSpin = (CGUISpinControlEx *)GetControl(CONTROL_SPIN_GENRE);
if (pSpin)
{
pSpin->Clear();
pSpin->AddLabel(g_localizeStrings.Get(593), -1);
pSpin->AddLabel(g_localizeStrings.Get(19500), EVCONTENTMASK_MOVIEDRAMA);
pSpin->AddLabel(g_localizeStrings.Get(19516), EVCONTENTMASK_NEWSCURRENTAFFAIRS);
pSpin->AddLabel(g_localizeStrings.Get(19532), EVCONTENTMASK_SHOW);
pSpin->AddLabel(g_localizeStrings.Get(19548), EVCONTENTMASK_SPORTS);
pSpin->AddLabel(g_localizeStrings.Get(19564), EVCONTENTMASK_CHILDRENYOUTH);
pSpin->AddLabel(g_localizeStrings.Get(19580), EVCONTENTMASK_MUSICBALLETDANCE);
pSpin->AddLabel(g_localizeStrings.Get(19596), EVCONTENTMASK_ARTSCULTURE);
pSpin->AddLabel(g_localizeStrings.Get(19612), EVCONTENTMASK_SOCIALPOLITICALECONOMICS);
pSpin->AddLabel(g_localizeStrings.Get(19628), EVCONTENTMASK_EDUCATIONALSCIENCE);
pSpin->AddLabel(g_localizeStrings.Get(19644), EVCONTENTMASK_LEISUREHOBBIES);
pSpin->AddLabel(g_localizeStrings.Get(19660), EVCONTENTMASK_SPECIAL);
pSpin->AddLabel(g_localizeStrings.Get(19499), EVCONTENTMASK_USERDEFINED);
pSpin->SetValue(m_searchfilter->m_iGenreType);
}
}
