DTC::ProgramList* Dvr::GetConflictList( int nStartIndex,
int nCount,
int nRecordId )
{
RecordingList recordingList;
RecordingList tmpList;
bool hasConflicts;
if (nRecordId <= 0)
nRecordId = -1;
LoadFromScheduler(tmpList, hasConflicts, "", nRecordId);
// Sort the upcoming into only those which are conflicts
RecordingList::iterator it = tmpList.begin();
for(; it < tmpList.end(); ++it)
{
if (nRecordId > 0 &&
(*it)->GetRecordingRuleID() != static_cast<uint>(nRecordId))
continue;
if (((*it)->GetRecordingStatus() == RecStatus::Conflict) &&
((*it)->GetRecordingStartTime() >= MythDate::current()))
{
recordingList.push_back(new RecordingInfo(**it));
}
}
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nStartIndex = min( nStartIndex, (int)recordingList.size() );
nCount = (nCount > 0) ? min( nCount, (int)recordingList.size() ) : recordingList.size();
int nEndIndex = min((nStartIndex + nCount), (int)recordingList.size() );
for( int n = nStartIndex; n < nEndIndex; n++)
{
ProgramInfo *pInfo = recordingList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( recordingList.size() );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
DTC::ProgramList* Dvr::GetUpcomingList( int nStartIndex,
int nCount,
bool bShowAll )
{
RecordingList recordingList;
RecordingList tmpList;
bool hasConflicts;
LoadFromScheduler(tmpList, hasConflicts);
// Sort the upcoming into only those which will record
RecordingList::iterator it = tmpList.begin();
for(; it < tmpList.end(); ++it)
{
if (!bShowAll && ((*it)->GetRecordingStatus() <= rsWillRecord) &&
((*it)->GetRecordingStartTime() >=
QDateTime::currentDateTime()))
{
recordingList.push_back(new RecordingInfo(**it));
}
else if (bShowAll && ((*it)->GetRecordingStartTime() >=
QDateTime::currentDateTime()))
{
recordingList.push_back(new RecordingInfo(**it));
}
}
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nStartIndex = min( nStartIndex, (int)recordingList.size() );
nCount = (nCount > 0) ? min( nCount, (int)recordingList.size() ) : recordingList.size();
int nEndIndex = min((nStartIndex + nCount), (int)recordingList.size() );
for( int n = nStartIndex; n < nEndIndex; n++)
{
ProgramInfo *pInfo = recordingList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true );
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( recordingList.size() );
pPrograms->setAsOf ( QDateTime::currentDateTime() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
bool GetProgramDetailList(
QDateTime &nextRecordingStart, bool *hasConflicts, ProgramDetailList *list)
{
nextRecordingStart = QDateTime();
bool dummy;
bool *conflicts = (hasConflicts) ? hasConflicts : &dummy;
ProgramList progList;
if (!LoadFromScheduler(progList, *conflicts))
return false;
// find the earliest scheduled recording
ProgramList::const_iterator it = progList.begin();
for (; it != progList.end(); ++it)
{
if (((*it)->GetRecordingStatus() == rsWillRecord) &&
(nextRecordingStart.isNull() ||
nextRecordingStart > (*it)->GetRecordingStartTime()))
{
nextRecordingStart = (*it)->GetRecordingStartTime();
}
}
if (!list)
return true;
// save the details of the earliest recording(s)
for (it = progList.begin(); it != progList.end(); ++it)
{
if (((*it)->GetRecordingStatus() == rsWillRecord) &&
((*it)->GetRecordingStartTime() == nextRecordingStart))
{
ProgramDetail prog;
prog.channame = (*it)->GetChannelName();
prog.title = (*it)->GetTitle();
prog.subtitle = (*it)->GetSubtitle();
prog.startTime = (*it)->GetRecordingStartTime();
prog.endTime = (*it)->GetRecordingEndTime();
list->push_back(prog);
}
}
return true;
}
DTC::Program* Guide::GetProgramDetails( int nChanId,
const QDateTime &dtStartTime )
{
if (!dtStartTime.isValid())
throw( "StartTime is invalid" );
// ----------------------------------------------------------------------
// -=>TODO: Add support for getting Recorded Program Info
// ----------------------------------------------------------------------
// Build add'l SQL statement for Program Listing
MSqlBindings bindings;
QString sSQL = "WHERE program.chanid = :ChanId "
"AND program.starttime = :StartTime ";
bindings[":ChanId" ] = nChanId;
bindings[":StartTime"] = dtStartTime;
// Get all Pending Scheduled Programs
ProgramList schedList;
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
ProgramList progList;
LoadFromProgram( progList, sSQL, bindings, schedList, false );
if ( progList.size() == 0)
throw( "Error Reading Program Info" );
// Build Response
DTC::Program *pProgram = new DTC::Program();
ProgramInfo *pInfo = progList[ 0 ];
FillProgramInfo( pProgram, pInfo, true );
return pProgram;
}
void ProgFinder::selectShowData(QString progTitle, int newCurShow)
{
progTitle = m_showList->GetValue();
QDateTime progStart = QDateTime::currentDateTime();
MSqlBindings bindings;
QString querystr = "WHERE program.title = :TITLE "
" AND program.endtime > :ENDTIME "
" AND channel.visible = 1 ";
bindings[":TITLE"] = progTitle;
bindings[":ENDTIME"] = progStart.toString("yyyy-MM-ddThh:mm:50");
LoadFromScheduler(m_schedList);
LoadFromProgram(m_showData, querystr, bindings, m_schedList, false);
updateTimesList();
m_timesList->SetItemCurrent(newCurShow);
}
void ProgFinder::selectShowData(QString progTitle, int newCurShow)
{
progTitle = m_showList->GetValue();
QDateTime progStart = MythDate::current();
MSqlBindings bindings;
QString querystr = "WHERE program.title = :TITLE "
" AND program.endtime > :ENDTIME "
" AND channel.visible = 1 ";
bindings[":TITLE"] = progTitle;
bindings[":ENDTIME"] = progStart.addSecs(50 - progStart.time().second());
LoadFromScheduler(m_schedList);
LoadFromProgram(m_showData, querystr, bindings, m_schedList);
updateTimesList();
m_timesList->SetItemCurrent(newCurShow);
}
bool IdleScreen::UpdateScheduledList()
{
{
// clear pending flag early in case something happens while
// we're updating
QMutexLocker lock(&m_schedUpdateMutex);
SetPendingSchedUpdate(false);
}
m_scheduledList.clear();
if (!gCoreContext->IsConnectedToMaster())
{
return false;
}
if (!LoadFromScheduler(m_scheduledList, m_hasConflicts))
return false;
UpdateScreen();
return true;
}
void ViewScheduleDiff::fillList(void)
{
m_inFill = true;
QString callsign;
QDateTime startts, recstartts;
bool dummy;
LoadFromScheduler(m_recListBefore, dummy);
LoadFromScheduler(m_recListAfter, dummy, m_altTable, m_recordid);
std::stable_sort(m_recListBefore.begin(), m_recListBefore.end(),
comp_recstart_less_than);
std::stable_sort(m_recListAfter.begin(), m_recListAfter.end(),
comp_recstart_less_than);
QDateTime now = QDateTime::currentDateTime();
ProgramList::iterator it = m_recListBefore.begin();
while (it != m_recListBefore.end())
{
if ((*it)->GetRecordingEndTime() >= now ||
(*it)->GetScheduledEndTime() >= now)
{
++it;
}
else
{
it = m_recListBefore.erase(it);
}
}
it = m_recListAfter.begin();
while (it != m_recListAfter.end())
{
if ((*it)->GetRecordingEndTime() >= now ||
(*it)->GetScheduledEndTime() >= now)
{
++it;
}
else
{
it = m_recListAfter.erase(it);
}
}
ProgramList::iterator pb = m_recListBefore.begin();
ProgramList::iterator pa = m_recListAfter.begin();
ProgramStruct s;
m_recList.clear();
while (pa != m_recListAfter.end() || pb != m_recListBefore.end())
{
s.before = (pb != m_recListBefore.end()) ? *pb : NULL;
s.after = (pa != m_recListAfter.end()) ? *pa : NULL;
if (pa == m_recListAfter.end())
{
++pb;
}
else if (pb == m_recListBefore.end())
{
++pa;
}
else
{
switch (comp_recstart(*pb, *pa))
{
case 0:
++pb;
++pa;
break;
case -1: // pb BEFORE pa
++pb;
s.after = NULL;
break;
case 1: // pa BEFORE pb
s.before = NULL;
++pa;
break;
}
}
if (s.before && s.after &&
(s.before->GetCardID() == s.after->GetCardID()) &&
(s.before->GetRecordingStatus() == s.after->GetRecordingStatus()))
{
continue;
}
m_recList.push_back(s);
}
m_inFill = false;
}
DTC::ProgramGuide *Guide::GetProgramGuide( const QDateTime &dtStartTime ,
const QDateTime &dtEndTime ,
int nStartChanId,
int nNumChannels,
bool bDetails )
{
if (!dtStartTime.isValid())
throw( "StartTime is invalid" );
if (!dtEndTime.isValid())
throw( "EndTime is invalid" );
if (dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
if (nNumChannels == 0)
nNumChannels = 1;
if (nNumChannels == -1)
nNumChannels = SHRT_MAX;
// ----------------------------------------------------------------------
// Find the ending channel Id
// ----------------------------------------------------------------------
int nEndChanId = nStartChanId;
MSqlQuery query(MSqlQuery::InitCon());
query.prepare( "SELECT chanid FROM channel WHERE (chanid >= :STARTCHANID )"
" ORDER BY chanid LIMIT :NUMCHAN" );
query.bindValue(":STARTCHANID", nStartChanId );
query.bindValue(":NUMCHAN" , nNumChannels );
if (!query.exec())
MythDB::DBError("Select ChanId", query);
query.first(); nStartChanId = query.value(0).toInt();
query.last(); nEndChanId = query.value(0).toInt();
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList progList;
ProgramList schedList;
MSqlBindings bindings;
QString sSQL = "WHERE program.chanid >= :StartChanId "
"AND program.chanid <= :EndChanId "
"AND program.endtime >= :StartDate "
"AND program.starttime <= :EndDate "
"GROUP BY program.starttime, channel.channum, "
"channel.callsign, program.title "
"ORDER BY program.chanid ";
bindings[":StartChanId"] = nStartChanId;
bindings[":EndChanId" ] = nEndChanId;
bindings[":StartDate" ] = dtStartTime;
bindings[":EndDate" ] = dtEndTime;
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
LoadFromProgram( progList, sSQL, bindings, schedList, false );
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramGuide *pGuide = new DTC::ProgramGuide();
int nChanCount = 0;
uint nCurChanId = 0;
DTC::ChannelInfo *pChannel = NULL;
for( uint n = 0; n < progList.size(); n++)
{
ProgramInfo *pInfo = progList[ n ];
if ( nCurChanId != pInfo->GetChanID() )
{
nChanCount++;
nCurChanId = pInfo->GetChanID();
pChannel = pGuide->AddNewChannel();
FillChannelInfo( pChannel, pInfo, bDetails );
}
DTC::Program *pProgram = pChannel->AddNewProgram();
FillProgramInfo( pProgram, pInfo, false, bDetails );
}
// ----------------------------------------------------------------------
pGuide->setStartTime ( dtStartTime );
pGuide->setEndTime ( dtEndTime );
pGuide->setStartChanId ( nStartChanId );
pGuide->setEndChanId ( nEndChanId );
pGuide->setNumOfChannels( nChanCount );
pGuide->setDetails ( bDetails );
pGuide->setCount ( progList.size());
pGuide->setAsOf ( QDateTime::currentDateTime() );
pGuide->setVersion ( MYTH_BINARY_VERSION );
pGuide->setProtoVer ( MYTH_PROTO_VERSION );
return pGuide;
}
DTC::ProgramGuide *Guide::GetProgramGuide( const QDateTime &rawStartTime ,
const QDateTime &rawEndTime ,
int nStartChanId,
int nNumChannels,
bool bDetails,
int nChannelGroupId )
{
if (!rawStartTime.isValid())
throw( "StartTime is invalid" );
if (!rawEndTime.isValid())
throw( "EndTime is invalid" );
QDateTime dtStartTime = rawStartTime.toUTC();
QDateTime dtEndTime = rawEndTime.toUTC();
if (dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
if (nNumChannels == 0)
nNumChannels = SHRT_MAX;
// ----------------------------------------------------------------------
// Find the ending channel Id
// ----------------------------------------------------------------------
int nEndChanId = nStartChanId;
MSqlQuery query(MSqlQuery::InitCon());
query.prepare( "SELECT chanid FROM channel WHERE (chanid >= :STARTCHANID )"
" ORDER BY chanid LIMIT :NUMCHAN" );
query.bindValue(":STARTCHANID", nStartChanId );
query.bindValue(":NUMCHAN" , nNumChannels );
if (!query.exec())
MythDB::DBError("Select ChanId", query);
query.first(); nStartChanId = query.value(0).toInt();
query.last(); nEndChanId = query.value(0).toInt();
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList progList;
ProgramList schedList;
MSqlBindings bindings;
// lpad is to allow natural sorting of numbers
QString sSQL;
if (nChannelGroupId > 0)
{
sSQL = "LEFT JOIN channelgroup ON program.chanid = channelgroup.chanid "
"WHERE channelgroup.grpid = :CHANGRPID AND ";
bindings[":CHANGRPID" ] = nChannelGroupId;
}
else
sSQL = "WHERE ";
sSQL += "visible != 0 "
"AND program.chanid >= :StartChanId "
"AND program.chanid <= :EndChanId "
"AND program.endtime >= :StartDate "
"AND program.starttime <= :EndDate "
"AND program.manualid = 0 " // Exclude programmes created purely for 'manual' recording schedules
"ORDER BY LPAD(CAST(channum AS UNSIGNED), 10, 0), "
" LPAD(channum, 10, 0), "
" callsign, "
" LPAD(program.chanid, 10, 0), "
" program.starttime ";
bindings[":StartChanId"] = nStartChanId;
bindings[":EndChanId" ] = nEndChanId;
bindings[":StartDate" ] = dtStartTime;
bindings[":EndDate" ] = dtEndTime;
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
LoadFromProgram( progList, sSQL, bindings, schedList );
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramGuide *pGuide = new DTC::ProgramGuide();
int nChanCount = 0;
uint nCurChanId = 0;
DTC::ChannelInfo *pChannel = NULL;
QString sCurCallsign;
uint nSkipChanId = 0;
for( uint n = 0; n < progList.size(); n++)
{
ProgramInfo *pInfo = progList[ n ];
if ( nSkipChanId == pInfo->GetChanID())
continue;
if ( nCurChanId != pInfo->GetChanID() )
{
nChanCount++;
nCurChanId = pInfo->GetChanID();
// Filter out channels with the same callsign, keeping just the
// first seen
if (sCurCallsign == pInfo->GetChannelSchedulingID())
{
nSkipChanId = pInfo->GetChanID();
continue;
}
pChannel = pGuide->AddNewChannel();
FillChannelInfo( pChannel, pInfo->GetChanID(), bDetails );
sCurCallsign = pChannel->CallSign();
}
DTC::Program *pProgram = pChannel->AddNewProgram();
FillProgramInfo( pProgram, pInfo, false, bDetails, false ); // No cast info
}
// ----------------------------------------------------------------------
pGuide->setStartTime ( dtStartTime );
pGuide->setEndTime ( dtEndTime );
pGuide->setStartChanId ( nStartChanId );
pGuide->setEndChanId ( nEndChanId );
pGuide->setNumOfChannels( nChanCount );
pGuide->setDetails ( bDetails );
pGuide->setCount ( progList.size());
pGuide->setAsOf ( MythDate::current() );
pGuide->setVersion ( MYTH_BINARY_VERSION );
pGuide->setProtoVer ( MYTH_PROTO_VERSION );
return pGuide;
}
DTC::ProgramList* Guide::GetProgramList(int nStartIndex,
int nCount,
const QDateTime& rawStartTime,
const QDateTime& rawEndTime,
int nChanId,
const QString& sTitleFilter,
const QString& sCategoryFilter,
const QString& sPersonFilter,
const QString& sKeywordFilter,
bool bOnlyNew,
bool bDetails,
const QString &sSort,
bool bDescending)
{
if (!rawStartTime.isNull() && !rawStartTime.isValid())
throw( "StartTime is invalid" );
if (!rawEndTime.isNull() && !rawEndTime.isValid())
throw( "EndTime is invalid" );
QDateTime dtStartTime = rawStartTime;
QDateTime dtEndTime = rawEndTime;
if (!rawEndTime.isNull() && dtEndTime < dtStartTime)
throw( "EndTime is before StartTime");
MSqlQuery query(MSqlQuery::InitCon());
// ----------------------------------------------------------------------
// Build SQL statement for Program Listing
// ----------------------------------------------------------------------
ProgramList progList;
ProgramList schedList;
MSqlBindings bindings;
QString sSQL;
if (!sPersonFilter.isEmpty())
{
sSQL = ", people, credits " // LEFT JOIN
"WHERE people.name LIKE :PersonFilter "
"AND credits.person = people.person "
"AND program.chanid = credits.chanid "
"AND program.starttime = credits.starttime AND ";
bindings[":PersonFilter"] = QString("%%1%").arg(sPersonFilter);
}
else
sSQL = "WHERE ";
sSQL += "visible != 0 AND program.manualid = 0 "; // Exclude programmes created purely for 'manual' recording schedules
if (nChanId < 0)
nChanId = 0;
if (nChanId > 0)
{
sSQL += "AND program.chanid = :ChanId ";
bindings[":ChanId"] = nChanId;
}
if (dtStartTime.isNull())
dtStartTime = QDateTime::currentDateTimeUtc();
sSQL += " AND program.endtime >= :StartDate ";
bindings[":StartDate"] = dtStartTime;
if (!dtEndTime.isNull())
{
sSQL += "AND program.starttime <= :EndDate ";
bindings[":EndDate"] = dtEndTime;
}
if (!sTitleFilter.isEmpty())
{
sSQL += "AND program.title LIKE :Title ";
bindings[":Title"] = QString("%%1%").arg(sTitleFilter);
}
if (!sCategoryFilter.isEmpty())
{
sSQL += "AND program.category LIKE :Category ";
bindings[":Category"] = sCategoryFilter;
}
if (!sKeywordFilter.isEmpty())
{
sSQL += "AND (program.title LIKE :Keyword1 "
"OR program.subtitle LIKE :Keyword2 "
"OR program.description LIKE :Keyword3) ";
QString filter = QString("%%1%").arg(sKeywordFilter);
bindings[":Keyword1"] = filter;
bindings[":Keyword2"] = filter;
bindings[":Keyword3"] = filter;
}
if (sSort == "starttime")
sSQL += "ORDER BY program.starttime ";
else if (sSort == "title")
sSQL += "ORDER BY program.title ";
else if (sSort == "channel")
sSQL += "ORDER BY channel.channum ";
else if (sSort == "duration")
sSQL += "ORDER BY (program.endtime - program.starttime) ";
else
sSQL += "ORDER BY program.starttime ";
if (bDescending)
sSQL += "DESC ";
else
sSQL += "ASC ";
// ----------------------------------------------------------------------
// Get all Pending Scheduled Programs
// ----------------------------------------------------------------------
bool hasConflicts;
LoadFromScheduler(schedList, hasConflicts);
// ----------------------------------------------------------------------
uint nTotalAvailable = 0;
LoadFromProgram( progList, sSQL, bindings, schedList,
(uint)nStartIndex, (uint)nCount, nTotalAvailable);
// ----------------------------------------------------------------------
// Build Response
// ----------------------------------------------------------------------
DTC::ProgramList *pPrograms = new DTC::ProgramList();
nCount = (int)progList.size();
int nEndIndex = (int)progList.size();
for( int n = 0; n < nEndIndex; n++)
{
ProgramInfo *pInfo = progList[ n ];
DTC::Program *pProgram = pPrograms->AddNewProgram();
FillProgramInfo( pProgram, pInfo, true, bDetails, false ); // No cast info, loading this takes far too long
}
// ----------------------------------------------------------------------
pPrograms->setStartIndex ( nStartIndex );
pPrograms->setCount ( nCount );
pPrograms->setTotalAvailable( nTotalAvailable );
pPrograms->setAsOf ( MythDate::current() );
pPrograms->setVersion ( MYTH_BINARY_VERSION );
pPrograms->setProtoVer ( MYTH_PROTO_VERSION );
return pPrograms;
}
void ViewScheduled::LoadList(bool useExistingData)
{
if (m_inFill)
return;
m_inFill = true;
MythUIButtonListItem *currentItem = m_schedulesList->GetItemCurrent();
QString callsign;
QDateTime startts, recstartts;
if (currentItem)
{
ProgramInfo *currentpginfo = qVariantValue<ProgramInfo*>
(currentItem->GetData());
if (currentpginfo)
{
callsign = currentpginfo->GetChannelSchedulingID();
startts = currentpginfo->GetScheduledStartTime();
recstartts = currentpginfo->GetRecordingStartTime();
}
}
QDateTime now = QDateTime::currentDateTime();
QMap<int, int> toomanycounts;
m_schedulesList->Reset();
if (m_groupList)
m_groupList->Reset();
m_recgroupList.clear();
if (!useExistingData)
LoadFromScheduler(m_recList, m_conflictBool);
ProgramList::iterator pit = m_recList.begin();
QString currentDate;
m_recgroupList[m_defaultGroup] = ProgramList(false);
m_recgroupList[m_defaultGroup].setAutoDelete(false);
while (pit != m_recList.end())
{
ProgramInfo *pginfo = *pit;
const RecStatusType recstatus = pginfo->GetRecordingStatus();
if ((pginfo->GetRecordingEndTime() >= now ||
pginfo->GetScheduledEndTime() >= now) &&
(m_showAll ||
recstatus <= rsWillRecord ||
recstatus == rsDontRecord ||
(recstatus == rsTooManyRecordings &&
++toomanycounts[pginfo->GetRecordingRuleID()] <= 1) ||
(recstatus > rsTooManyRecordings &&
recstatus != rsRepeat &&
recstatus != rsNeverRecord)))
{
m_cardref[pginfo->GetCardID()]++;
if (pginfo->GetCardID() > m_maxcard)
m_maxcard = pginfo->GetCardID();
m_inputref[pginfo->GetInputID()]++;
if (pginfo->GetInputID() > m_maxinput)
m_maxinput = pginfo->GetInputID();
QDate date = (pginfo->GetRecordingStartTime()).date();
m_recgroupList[date].push_back(pginfo);
m_recgroupList[date].setAutoDelete(false);
m_recgroupList[m_defaultGroup].push_back(pginfo);
++pit;
}
else
{
pit = m_recList.erase(pit);
continue;
}
}
if (m_groupList)
{
QString label;
QMap<QDate,ProgramList>::iterator dateit = m_recgroupList.begin();
while (dateit != m_recgroupList.end())
{
if (dateit.key().isNull())
label = tr("All");
else
label = dateit.key().toString(m_dateFormat);
new MythUIButtonListItem(m_groupList, label,
qVariantFromValue(dateit.key()));
++dateit;
}
if (!m_recgroupList.contains(m_currentGroup))
m_groupList->SetValueByData(qVariantFromValue(m_currentGroup));
}
FillList();
// Restore position after a list update
if (!callsign.isEmpty())
{
ProgramList plist;
if (!m_recgroupList.contains(m_currentGroup))
m_currentGroup = m_defaultGroup;
plist = m_recgroupList[m_currentGroup];
int listPos = ((int) plist.size()) - 1;
int i;
for (i = listPos; i >= 0; --i)
{
ProgramInfo *pginfo = plist[i];
if (callsign == pginfo->GetChannelSchedulingID() &&
startts == pginfo->GetScheduledStartTime())
{
listPos = i;
break;
}
else if (recstartts <= pginfo->GetRecordingStartTime())
listPos = i;
}
m_schedulesList->SetItemCurrent(listPos);
}
m_inFill = false;
m_needFill = false;
}
void ViewScheduled::Load(void)
{
LoadFromScheduler(m_recList, m_conflictBool);
}