Ticket #6862: 6862-v4.patch

File 6862-v4.patch, 93.4 KB (added by danielk, 11 years ago)

updated patch

  • libs/libmythtv/recordinglist.h

     
    99// of the list while the linked list erase() is always O(1), but all other
    1010// operations are faster with the deque.
    1111
    12 #define PGLIST_USE_LINKED_LIST
     12//#define PGLIST_USE_LINKED_LIST
    1313
    1414// C++ headers
    1515#ifdef PGLIST_USE_LINKED_LIST
     
    2929// MythTV headers
    3030#include "mythexp.h"
    3131#include "mythdbcon.h"
    32 #include "programinfo.h" // for ProgramDetailList
    3332
     33class RecordingList;
     34MPUBLIC bool LoadFromScheduler(
     35    RecordingList      &destination,
     36    bool               &hasConflicts,
     37    QString             altTable = "",
     38    int                 recordid = -1);
     39
    3440/** \class RecordingList
    3541 *  \brief List of RecordingInfo instances, with helper functions.
    3642 */
     
    4551
    4652    RecordingInfo *operator[](uint index);
    4753    const RecordingInfo *operator[](uint index) const;
    48     bool operator==(const RecordingList &b) const;
    4954
    50     bool FromScheduler(bool    &hasConflicts,
    51                        QString  altTable = "",
    52                        int      recordid = -1);
    53 
    54     bool FromScheduler(void)
    55     {
    56         bool dummyConflicts;
    57         return FromScheduler(dummyConflicts, "", -1);
    58     };
    59 
    60     bool FromProgram(const QString &sql, MSqlBindings &bindings,
    61                      RecordingList &schedList, bool oneChanid = false);
    62 
    63     bool FromProgram(const QString &sql, MSqlBindings &bindings)
    64     {
    65         RecordingList dummySched;
    66         return FromProgram(sql, bindings, dummySched);
    67     }
    68 
    69     bool FromRecorded( bool bDescending, RecordingList *pSchedList);
    70 
    71     bool FromOldRecorded(const QString &sql, MSqlBindings &bindings);
    72 
    73     static bool GetProgramDetailList(
    74         QDateTime         &nextRecordingStart,
    75         bool              *hasConflicts = NULL,
    76         ProgramDetailList *list = NULL);
    77 
    7855    RecordingInfo *take(uint i);
    7956    iterator erase(iterator it);
    8057    void clear(void);
     
    9168    void push_back(RecordingInfo *pginfo) { pglist.push_back(pginfo); }
    9269
    9370    // compatibility with old Q3PtrList
    94     bool isEmpty(void) const { return empty(); }
    95     size_t count(void) const { return size(); }
    96     RecordingInfo *at(uint index) { return (*this)[index]; }
    97     void prepend(RecordingInfo *pginfo) { push_front(pginfo); }
    98     void append(RecordingInfo *pginfo) { push_back(pginfo); }
    9971    void setAutoDelete(bool auto_delete) { autodelete = auto_delete; }
    10072
    10173  protected:
  • libs/libmythtv/programdetail.cpp

     
     1#include "programdetail.h"
     2#include "programlist.h"
     3#include "programinfo.h"
     4
     5bool GetProgramDetailList(
     6    QDateTime &nextRecordingStart, bool *hasConflicts, ProgramDetailList *list)
     7{
     8    nextRecordingStart = QDateTime();
     9
     10    bool dummy;
     11    bool *conflicts = (hasConflicts) ? hasConflicts : &dummy;
     12
     13    ProgramList progList;
     14    if (!LoadFromScheduler(progList, *conflicts))
     15        return false;
     16
     17    // find the earliest scheduled recording
     18    ProgramList::const_iterator it = progList.begin();
     19    for (; it != progList.end(); ++it)
     20    {
     21        if (((*it)->recstatus == rsWillRecord) &&
     22            (nextRecordingStart.isNull() ||
     23             nextRecordingStart > (*it)->recstartts))
     24        {
     25            nextRecordingStart = (*it)->recstartts;
     26        }
     27    }
     28
     29    if (!list)
     30        return true;
     31
     32    // save the details of the earliest recording(s)
     33    for (it = progList.begin(); it != progList.end(); ++it)
     34    {
     35        if (((*it)->recstatus  == rsWillRecord) &&
     36            ((*it)->recstartts == nextRecordingStart))
     37        {
     38            ProgramDetail prog;
     39            prog.channame  = (*it)->channame;
     40            prog.title     = (*it)->title;
     41            prog.subtitle  = (*it)->subtitle;
     42            prog.startTime = (*it)->recstartts;
     43            prog.endTime   = (*it)->recendts;
     44            list->push_back(prog);
     45        }
     46    }
     47
     48    return true;
     49}
  • libs/libmythtv/programdetail.h

     
     1#ifndef _PROGRAM_DETAIL_H_
     2#define _PROGRAM_DETAIL_H_
     3
     4// C++ headers
     5#include <vector>
     6using namespace std;
     7
     8// Qt headers
     9#include <QString>
     10#include <QDateTime>
     11
     12// MythTV headers
     13#include "mythexp.h"
     14
     15class MPUBLIC ProgramDetail
     16{
     17  public:
     18    QString   channame;
     19    QString   title;
     20    QString   subtitle;
     21    QDateTime startTime;
     22    QDateTime endTime;
     23};
     24typedef vector<ProgramDetail> ProgramDetailList;
     25
     26bool GetProgramDetailList(
     27    QDateTime         &nextRecordingStart,
     28    bool              *hasConflicts = NULL,
     29    ProgramDetailList *list = NULL);
     30
     31#endif // _PROGRAM_DETAIL_H_
  • libs/libmythtv/libmythtv.pro

     
    155155HEADERS += transporteditor.h        listingsources.h
    156156HEADERS += myth_imgconvert.h
    157157HEADERS += channelgroup.h           channelgroupsettings.h
    158 HEADERS += recordingrule.h
     158HEADERS += recordingrule.h          programdetail.h
    159159
    160160SOURCES += recordinginfo.cpp        recordinglist.cpp
    161161SOURCES += RingBuffer.cpp           avfringbuffer.cpp
     
    176176SOURCES += transporteditor.cpp
    177177SOURCES += channelgroup.cpp         channelgroupsettings.cpp
    178178SOURCES += myth_imgconvert.cpp
    179 SOURCES += recordingrule.cpp
     179SOURCES += recordingrule.cpp        programdetail.cpp
    180180
    181181# DiSEqC
    182182HEADERS += diseqc.h                 diseqcsettings.h
  • libs/libmythtv/viewschdiff.cpp

     
    397397        }
    398398    }
    399399
    400     recListBefore.FromScheduler(conflictBool);
    401     recListAfter.FromScheduler(conflictBool, altTable, recordid);
     400    LoadFromScheduler(recListBefore, conflictBool);
     401    LoadFromScheduler(recListAfter,  conflictBool, altTable, recordid);
    402402
    403403    recListBefore.sort(comp_recstart_less_than);
    404404    recListAfter.sort(comp_recstart_less_than);
  • libs/libmythtv/recordinginfo.h

     
    2121
    2222class MPUBLIC RecordingInfo : public ProgramInfo
    2323{
     24    friend class RecordingList;
     25
    2426  public:
    2527    RecordingInfo(void) : record(NULL) {}
    2628    RecordingInfo(const RecordingInfo &other) :
    2729        ProgramInfo(other), record(NULL) {}
    2830    RecordingInfo(const ProgramInfo &other) :
    2931        ProgramInfo(other), record(NULL) {}
     32
     33  protected:
     34    RecordingInfo(const MSqlQuery   &query,
     35                  const ProgramList &schedList,
     36                  bool               oneChanid) :
     37        ProgramInfo(query, schedList, oneChanid), record(NULL) {}
     38
     39  public:
    3040    RecordingInfo &operator=(const RecordingInfo &other) {return clone(other);}
    3141    RecordingInfo &operator=(const ProgramInfo &other) { return clone(other); }
    3242
  • libs/libmythtv/tv_play.cpp

     
    76817681    };
    76827682
    76837683    ProgramList progList;
    7684     progList.FromProgram(querystr, bindings);
     7684    ProgramList dummySched;
     7685    LoadFromProgram(progList, querystr, bindings, dummySched, false);
    76857686
    7686     if (progList.isEmpty())
     7687    if (progList.empty())
    76877688    {
    76887689        infoMap["dbstarttime"] = "";
    76897690        return;
     
    1152511526        for (Iprog = progLists.begin(); Iprog != progLists.end(); Iprog++)
    1152611527        {
    1152711528            const ProgramList &plist = *Iprog;
    11528             int progIndex = plist.count();
     11529            uint progIndex = (uint) plist.size();
    1152911530
    1153011531            if (plist[0]->recgroup != currecgroup)
    1153111532            {
  • libs/libmythtv/recordinglist.cpp

     
    44#include "mythcontext.h"
    55#include "mythdb.h"
    66#include "util.h"
    7 #include "recordinginfo.h"
    87#include "recordinglist.h"
     8#include "recordinginfo.h"
    99#include "jobqueue.h"
    1010
    1111RecordingList::~RecordingList(void)
     
    3737    return (*(const_cast<RecordingList*>(this)))[index];
    3838}
    3939
    40 bool RecordingList::operator==(const RecordingList &b) const
    41 {
    42     const_iterator it_a  = pglist.begin();
    43     const_iterator it_b  = b.pglist.begin();
    44     const_iterator end_a = pglist.end();
    45     const_iterator end_b = b.pglist.end();
    46 
    47     for (; it_a != end_a && it_b != end_b; ++it_a, ++it_b)
    48     {
    49         if (*it_a != *it_b)
    50             return false;
    51     }
    52 
    53     return (it_a == end_a) && (it_b == end_b);
    54 }
    55 
    5640RecordingInfo *RecordingList::take(uint index)
    5741{
    5842#ifndef PGLIST_USE_LINKED_LIST
     
    11296#endif
    11397}
    11498
    115 bool RecordingList::FromScheduler(bool &hasConflicts, QString tmptable,
    116                                 int recordid)
     99bool LoadFromScheduler(
     100    RecordingList &destination, bool &hasConflicts,
     101    QString tmptable, int recordid)
    117102{
    118     clear();
     103    destination.clear();
    119104    hasConflicts = false;
    120105
    121106    if (gContext->IsBackend())
    122107        return false;
    123108
    124109    QString query;
    125     if (tmptable != "")
     110    if (!tmptable.isEmpty())
    126111    {
    127112        query = QString("QUERY_GETALLPENDING %1 %2")
    128                         .arg(tmptable).arg(recordid);
    129     } else {
     113            .arg(tmptable).arg(recordid);
     114    }
     115    else
     116    {
    130117        query = QString("QUERY_GETALLPENDING");
    131118    }
    132119
     
    134121    if (!gContext->SendReceiveStringList(slist) || slist.size() < 2)
    135122    {
    136123        VERBOSE(VB_IMPORTANT,
    137                 "RecordingList::FromScheduler(): Error querying master.");
     124                "LoadFromScheduler(): Error querying master.");
    138125        return false;
    139126    }
    140127
     
    148135        RecordingInfo *p = new RecordingInfo();
    149136        result = p->FromStringList(sit, slist.end());
    150137        if (result)
    151             pglist.push_back(p);
     138            destination.push_back(p);
    152139        else
    153140            delete p;
    154141    }
    155142
    156     if (pglist.size() != slist[1].toUInt())
     143    if (destination.size() != slist[1].toUInt())
    157144    {
    158145        VERBOSE(VB_IMPORTANT,
    159                 "RecordingList::FromScheduler(): Length mismatch");
    160         clear();
     146                "LoadFromScheduler(): Length mismatch.");
     147        destination.clear();
    161148        result = false;
    162149    }
    163150
    164151    return result;
    165152}
    166 
    167 bool RecordingList::FromProgram(const QString &sql, MSqlBindings &bindings,
    168                               RecordingList &schedList, bool oneChanid)
    169 {
    170     clear();
    171 
    172     QString querystr = QString(
    173         "SELECT DISTINCT program.chanid, program.starttime, program.endtime, "
    174         "    program.title, program.subtitle, program.description, "
    175         "    program.category, channel.channum, channel.callsign, "
    176         "    channel.name, program.previouslyshown, channel.commmethod, "
    177         "    channel.outputfilters, program.seriesid, program.programid, "
    178         "    program.airdate, program.stars, program.originalairdate, "
    179         "    program.category_type, oldrecstatus.recordid, "
    180         "    oldrecstatus.rectype, oldrecstatus.recstatus, "
    181         "    oldrecstatus.findid "
    182         "FROM program "
    183         "LEFT JOIN channel ON program.chanid = channel.chanid "
    184         "LEFT JOIN oldrecorded AS oldrecstatus ON "
    185         "    program.title = oldrecstatus.title AND "
    186         "    channel.callsign = oldrecstatus.station AND "
    187         "    program.starttime = oldrecstatus.starttime "
    188         ) + sql;
    189 
    190     if (!sql.contains(" GROUP BY "))
    191         querystr += " GROUP BY program.starttime, channel.channum, "
    192             "  channel.callsign, program.title ";
    193     if (!sql.contains(" ORDER BY "))
    194     {
    195         querystr += " ORDER BY program.starttime, ";
    196         QString chanorder = gContext->GetSetting("ChannelOrdering", "channum");
    197         if (chanorder != "channum")
    198             querystr += chanorder + " ";
    199         else // approximation which the DB can handle
    200             querystr += "atsc_major_chan,atsc_minor_chan,channum,callsign ";
    201     }
    202     if (!sql.contains(" LIMIT "))
    203         querystr += " LIMIT 20000 ";
    204 
    205     MSqlQuery query(MSqlQuery::InitCon());
    206     query.prepare(querystr);
    207     MSqlBindings::const_iterator it;
    208     for (it = bindings.begin(); it != bindings.end(); ++it)
    209         if (querystr.contains(it.key()))
    210             query.bindValue(it.key(), it.value());
    211 
    212     if (!query.exec())
    213     {
    214         MythDB::DBError("RecordingList::FromProgram", query);
    215         return false;
    216     }
    217 
    218     while (query.next())
    219     {
    220         RecordingInfo *p = new RecordingInfo;
    221         p->chanid = query.value(0).toString();
    222         p->startts = QDateTime::fromString(query.value(1).toString(),
    223                                            Qt::ISODate);
    224         p->endts = QDateTime::fromString(query.value(2).toString(),
    225                                          Qt::ISODate);
    226         p->recstartts = p->startts;
    227         p->recendts = p->endts;
    228         p->lastmodified = p->startts;
    229         p->title = query.value(3).toString();
    230         p->subtitle = query.value(4).toString();
    231         p->description = query.value(5).toString();
    232         p->category = query.value(6).toString();
    233         p->chanstr = query.value(7).toString();
    234         p->chansign = query.value(8).toString();
    235         p->channame = query.value(9).toString();
    236         p->repeat = query.value(10).toInt();
    237         p->chancommfree = COMM_DETECT_COMMFREE == query.value(11).toInt();
    238         p->chanOutputFilters = query.value(12).toString();
    239         p->seriesid = query.value(13).toString();
    240         p->programid = query.value(14).toString();
    241         p->year = query.value(15).toString();
    242         p->stars = query.value(16).toString().toFloat();
    243 
    244         if (query.value(17).isNull() || query.value(17).toString().isEmpty())
    245         {
    246             p->originalAirDate = QDate (0, 1, 1);
    247             p->hasAirDate = false;
    248         }
    249         else
    250         {
    251             p->originalAirDate =
    252                 QDate::fromString(query.value(17).toString(),Qt::ISODate);
    253 
    254             if (p->originalAirDate > QDate(1940, 1, 1))
    255                 p->hasAirDate = true;
    256             else
    257                 p->hasAirDate = false;
    258         }
    259         p->catType = query.value(18).toString();
    260         p->recordid = query.value(19).toInt();
    261         p->rectype = RecordingType(query.value(20).toInt());
    262         p->recstatus = RecStatusType(query.value(21).toInt());
    263         p->findid = query.value(22).toInt();
    264 
    265         iterator it = schedList.pglist.begin();
    266         for (; it != schedList.pglist.end(); ++it)
    267         {
    268             RecordingInfo *s = *it;
    269             if (p->IsSameTimeslot(*s))
    270             {
    271                 p->recordid = s->recordid;
    272                 p->recstatus = s->recstatus;
    273                 p->rectype = s->rectype;
    274                 p->recpriority = s->recpriority;
    275                 p->recstartts = s->recstartts;
    276                 p->recendts = s->recendts;
    277                 p->cardid = s->cardid;
    278                 p->inputid = s->inputid;
    279                 p->dupin = s->dupin;
    280                 p->dupmethod = s->dupmethod;
    281                 p->findid = s->findid;
    282 
    283                 if (s->recstatus == rsWillRecord ||
    284                     s->recstatus == rsRecording)
    285                 {
    286                     if (oneChanid)
    287                     {
    288                         p->chanid   = s->chanid;
    289                         p->chanstr  = s->chanstr;
    290                         p->chansign = s->chansign;
    291                         p->channame = s->channame;
    292                     }
    293                     else if ((p->chanid != s->chanid) &&
    294                              (p->chanstr != s->chanstr))
    295                     {
    296                         p->recstatus = rsOtherShowing;
    297                     }
    298                 }
    299             }
    300         }
    301 
    302         pglist.push_back(p);
    303     }
    304 
    305     return true;
    306 }
    307 
    308 bool RecordingList::FromRecorded( bool bDescending, RecordingList *pSchedList )
    309 {
    310     clear();
    311 
    312     QString     fs_db_name = "";
    313     QDateTime   rectime    = QDateTime::currentDateTime().addSecs(
    314                               -gContext->GetNumSetting("RecordOverTime"));
    315 
    316     QString ip        = gContext->GetSetting("BackendServerIP");
    317     QString port      = gContext->GetSetting("BackendServerPort");
    318 
    319     // ----------------------------------------------------------------------
    320 
    321     QMap<QString, int> inUseMap;
    322 
    323     QString     inUseKey;
    324     QString     inUseForWhat;
    325     QDateTime   oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
    326 
    327     MSqlQuery   query(MSqlQuery::InitCon());
    328 
    329     query.prepare("SELECT DISTINCT chanid, starttime, recusage "
    330                   " FROM inuseprograms WHERE lastupdatetime >= :ONEHOURAGO ;");
    331     query.bindValue(":ONEHOURAGO", oneHourAgo);
    332 
    333     if (query.exec())
    334     {
    335         while (query.next())
    336         {
    337             inUseKey = query.value(0).toString() + " " +
    338                        query.value(1).toDateTime().toString(Qt::ISODate);
    339             inUseForWhat = query.value(2).toString();
    340 
    341             if (!inUseMap.contains(inUseKey))
    342                 inUseMap[inUseKey] = 0;
    343 
    344             if ((inUseForWhat == "player") ||
    345                 (inUseForWhat == "preview player") ||
    346                 (inUseForWhat == "PIP player"))
    347                 inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSEPLAYING;
    348             else if (inUseForWhat == "recorder")
    349                 inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSERECORDING;
    350         }
    351     }
    352 
    353     // ----------------------------------------------------------------------
    354 
    355     QMap<QString,bool> is_job_running;
    356     query.prepare("SELECT chanid, starttime, status FROM jobqueue "
    357                   "WHERE type = :TYPE");
    358     query.bindValue(":TYPE", JOB_COMMFLAG);
    359     if (query.exec())
    360     {
    361         while (query.next())
    362         {
    363             uint      chanid     = query.value(0).toUInt();
    364             QDateTime recstartts = query.value(1).toDateTime();
    365             int       tmpStatus  = query.value(2).toInt();
    366             if ((tmpStatus != JOB_UNKNOWN) &&
    367                 (tmpStatus != JOB_QUEUED) &&
    368                 (!(tmpStatus & JOB_DONE)))
    369             {
    370                 is_job_running[
    371                     QString("%1###%2")
    372                     .arg(chanid).arg(recstartts.toString())] = true;
    373             }
    374         }
    375     }
    376 
    377     // ----------------------------------------------------------------------
    378 
    379     QString thequery =
    380         "SELECT recorded.chanid,recorded.starttime,recorded.endtime,"
    381         "recorded.title,recorded.subtitle,recorded.description,"
    382         "recorded.hostname,channum,name,callsign,commflagged,cutlist,"
    383         "recorded.autoexpire,editing,bookmark,recorded.category,"
    384         "recorded.recgroup,record.dupin,record.dupmethod,"
    385         "record.recordid,outputfilters,"
    386         "recorded.seriesid,recorded.programid,recorded.filesize, "
    387         "recorded.lastmodified, recorded.findid, "
    388         "recorded.originalairdate, recorded.playgroup, "
    389         "recorded.basename, recorded.progstart, "
    390         "recorded.progend, recorded.stars, "
    391         "recordedprogram.audioprop+0, recordedprogram.videoprop+0, "
    392         "recordedprogram.subtitletypes+0, recorded.watched, "
    393         "recorded.storagegroup "
    394         "FROM recorded "
    395         "LEFT JOIN record ON recorded.recordid = record.recordid "
    396         "LEFT JOIN channel ON recorded.chanid = channel.chanid "
    397         "LEFT JOIN recordedprogram ON "
    398         " ( recorded.chanid    = recordedprogram.chanid AND "
    399         "   recorded.progstart = recordedprogram.starttime ) "
    400         "WHERE ( recorded.deletepending = 0 OR "
    401         "        recorded.lastmodified <= DATE_SUB(NOW(), INTERVAL 5 MINUTE) "
    402         "      ) "
    403         "ORDER BY recorded.starttime";
    404 
    405     if ( bDescending )
    406         thequery += " DESC";
    407 
    408     QString chanorder = gContext->GetSetting("ChannelOrdering", "channum");
    409     if (chanorder != "channum")
    410         thequery += ", " + chanorder;
    411     else // approximation which the DB can handle
    412         thequery += ",atsc_major_chan,atsc_minor_chan,channum,callsign";
    413 
    414     query.prepare(thequery);
    415 
    416     if (!query.exec())
    417     {
    418         MythDB::DBError("RecordingList::FromRecorded", query);
    419         return true;
    420     }
    421 
    422     while (query.next())
    423     {
    424         RecordingInfo *proginfo = new RecordingInfo;
    425 
    426         proginfo->chanid        = query.value(0).toString();
    427         proginfo->startts       = query.value(29).toDateTime();
    428         proginfo->endts         = query.value(30).toDateTime();
    429         proginfo->recstartts    = query.value(1).toDateTime();
    430         proginfo->recendts      = query.value(2).toDateTime();
    431         proginfo->title         = query.value(3).toString();
    432         proginfo->subtitle      = query.value(4).toString();
    433         proginfo->description   = query.value(5).toString();
    434         proginfo->hostname      = query.value(6).toString();
    435 
    436         proginfo->dupin         = RecordingDupInType(query.value(17).toInt());
    437         proginfo->dupmethod     = RecordingDupMethodType(query.value(18).toInt());
    438         proginfo->recordid      = query.value(19).toInt();
    439         proginfo->chanOutputFilters = query.value(20).toString();
    440         proginfo->seriesid      = query.value(21).toString();
    441         proginfo->programid     = query.value(22).toString();
    442         proginfo->filesize      = stringToLongLong(query.value(23).toString());
    443         proginfo->lastmodified  = QDateTime::fromString(query.value(24).toString(), Qt::ISODate);
    444         proginfo->findid        = query.value(25).toInt();
    445 
    446         if (query.value(26).isNull() ||
    447             query.value(26).toString().isEmpty())
    448         {
    449             proginfo->originalAirDate = QDate (0, 1, 1);
    450             proginfo->hasAirDate      = false;
    451         }
    452         else
    453         {
    454             proginfo->originalAirDate =
    455                 QDate::fromString(query.value(26).toString(),Qt::ISODate);
    456 
    457             if (proginfo->originalAirDate > QDate(1940, 1, 1))
    458                 proginfo->hasAirDate  = true;
    459             else
    460                 proginfo->hasAirDate  = false;
    461         }
    462 
    463         proginfo->pathname = query.value(28).toString();
    464 
    465 
    466         if (proginfo->hostname.isEmpty() || proginfo->hostname.isNull())
    467             proginfo->hostname = gContext->GetHostName();
    468 
    469         if (!query.value(7).toString().isEmpty())
    470         {
    471             proginfo->chanstr  = query.value(7).toString();
    472             proginfo->channame = query.value(8).toString();
    473             proginfo->chansign = query.value(9).toString();
    474         }
    475         else
    476         {
    477             proginfo->chanstr  = "#" + proginfo->chanid;
    478             proginfo->channame = "#" + proginfo->chanid;
    479             proginfo->chansign = "#" + proginfo->chanid;
    480         }
    481 
    482         int flags = 0;
    483 
    484         flags |= (query.value(10).toInt() == 1)           ? FL_COMMFLAG : 0;
    485         flags |= (query.value(11).toInt() == 1)           ? FL_CUTLIST  : 0;
    486         flags |=  query.value(12).toInt()                 ? FL_AUTOEXP  : 0;
    487         flags |= (query.value(14).toInt() == 1)           ? FL_BOOKMARK : 0;
    488         flags |= (query.value(35).toInt() == 1)           ? FL_WATCHED  : 0;
    489 
    490         inUseKey = query.value(0).toString() + " " +
    491             query.value(1).toDateTime().toString(Qt::ISODate);
    492 
    493         if (inUseMap.contains(inUseKey))
    494             flags |= inUseMap[inUseKey];
    495 
    496         if (query.value(13).toInt())
    497         {
    498             flags |= FL_EDITING;
    499         }
    500         else if (query.value(10).toInt() == COMM_FLAG_PROCESSING)
    501         {
    502             bool running =
    503                 is_job_running.find(
    504                     QString("%1###%2")
    505                     .arg(proginfo->chanid)
    506                     .arg(proginfo->recstartts.toString())) !=
    507                 is_job_running.end();
    508             if (running)
    509                 flags |= FL_EDITING;
    510             else
    511                 proginfo->SetCommFlagged(COMM_FLAG_NOT_FLAGGED);
    512         }
    513 
    514         proginfo->programflags = flags;
    515 
    516         proginfo->audioproperties = query.value(32).toInt();
    517         proginfo->videoproperties = query.value(33).toInt();
    518         proginfo->subtitleType = query.value(34).toInt();
    519 
    520         proginfo->category     = query.value(15).toString();
    521         proginfo->recgroup     = query.value(16).toString();
    522         proginfo->playgroup    = query.value(27).toString();
    523         proginfo->storagegroup = query.value(36).toString();
    524         proginfo->recstatus    = rsRecorded;
    525 
    526         if ((pSchedList != NULL) && (proginfo->recendts > rectime))
    527         {
    528             iterator it = pSchedList->pglist.begin();
    529             for (; it != pSchedList->pglist.end(); ++it)
    530             {
    531                 ProgramInfo *s = *it;
    532                 if (s && s->recstatus    == rsRecording &&
    533                     proginfo->chanid     == s->chanid   &&
    534                     proginfo->recstartts == s->recstartts)
    535                 {
    536                     proginfo->recstatus = rsRecording;
    537                     break;
    538                 }
    539             }
    540         }
    541 
    542         proginfo->stars = query.value(31).toDouble();
    543 
    544         pglist.push_back(proginfo);
    545     }
    546 
    547     return true;
    548 }
    549 
    550 
    551 bool RecordingList::FromOldRecorded(const QString &sql, MSqlBindings &bindings)
    552 {
    553     clear();
    554     MSqlQuery query(MSqlQuery::InitCon());
    555 
    556     query.prepare("SELECT oldrecorded.chanid, starttime, endtime, "
    557                   " title, subtitle, description, category, seriesid, "
    558                   " programid, channel.channum, channel.callsign, "
    559                   " channel.name, findid, rectype, recstatus, recordid, "
    560                   " duplicate "
    561                   " FROM oldrecorded "
    562                   " LEFT JOIN channel ON oldrecorded.chanid = channel.chanid "
    563                   + sql);
    564     query.bindValues(bindings);
    565 
    566     if (!query.exec() || !query.isActive())
    567     {
    568         MythDB::DBError("RecordingList::FromOldRecorded", query);
    569         return false;
    570     }
    571 
    572     while (query.next())
    573     {
    574         RecordingInfo *p = new RecordingInfo;
    575         p->chanid = query.value(0).toString();
    576         p->startts = QDateTime::fromString(query.value(1).toString(),
    577                                            Qt::ISODate);
    578         p->endts = QDateTime::fromString(query.value(2).toString(),
    579                                          Qt::ISODate);
    580         p->recstartts = p->startts;
    581         p->recendts = p->endts;
    582         p->lastmodified = p->startts;
    583         p->title = query.value(3).toString();
    584         p->subtitle = query.value(4).toString();
    585         p->description = query.value(5).toString();
    586         p->category = query.value(6).toString();
    587         p->seriesid = query.value(7).toString();
    588         p->programid = query.value(8).toString();
    589         p->chanstr = query.value(9).toString();
    590         p->chansign = query.value(10).toString();
    591         p->channame = query.value(11).toString();
    592         p->findid = query.value(12).toInt();
    593         p->rectype = RecordingType(query.value(13).toInt());
    594         p->recstatus = RecStatusType(query.value(14).toInt());
    595         p->recordid = query.value(15).toInt();
    596         p->duplicate = query.value(16).toInt();
    597 
    598         pglist.push_back(p);
    599     }
    600 
    601     return true;
    602 }
    603 
    604 bool RecordingList::GetProgramDetailList(
    605     QDateTime &nextRecordingStart, bool *hasConflicts, ProgramDetailList *list)
    606 {
    607     nextRecordingStart = QDateTime();
    608 
    609     bool dummy;
    610     bool *conflicts = (hasConflicts) ? hasConflicts : &dummy;
    611 
    612     RecordingList progList;
    613     if (!progList.FromScheduler(*conflicts))
    614         return false;
    615 
    616     // find the earliest scheduled recording
    617     RecordingList::const_iterator it = progList.begin();
    618     for (; it != progList.end(); ++it)
    619     {
    620         if (((*it)->recstatus == rsWillRecord) &&
    621             (nextRecordingStart.isNull() ||
    622              nextRecordingStart > (*it)->recstartts))
    623         {
    624             nextRecordingStart = (*it)->recstartts;
    625         }
    626     }
    627 
    628     if (!list)
    629         return true;
    630 
    631     // save the details of the earliest recording(s)
    632     for (it = progList.begin(); it != progList.end(); ++it)
    633     {
    634         if (((*it)->recstatus  == rsWillRecord) &&
    635             ((*it)->recstartts == nextRecordingStart))
    636         {
    637             ProgramDetail prog;
    638             prog.channame  = (*it)->channame;
    639             prog.title     = (*it)->title;
    640             prog.subtitle  = (*it)->subtitle;
    641             prog.startTime = (*it)->recstartts;
    642             prog.endTime   = (*it)->recendts;
    643             list->push_back(prog);
    644         }
    645     }
    646 
    647     return true;
    648 }
  • libs/libmyth/programinfo.h

     
    213213 *  view or record.
    214214 */
    215215
     216class MSqlQuery;
     217class ProgramList;
     218
    216219class MPUBLIC ProgramInfo
    217220{
     221    friend class ProgramList;
     222
    218223  public:
    219     // Constructors and bulk set methods.
     224    // Constructors
    220225    ProgramInfo(void);
    221226    ProgramInfo(const ProgramInfo &other);
     227    ProgramInfo(const MSqlQuery   &query,
     228                const ProgramList &schedList,
     229                bool               oneChanid);
     230    // Bulk set methods
     231  public:
    222232
    223233    typedef enum {
    224234        kNoProgram           = 0,
     
    462472
    463473Q_DECLARE_METATYPE(ProgramInfo*)
    464474
    465 class MPUBLIC ProgramDetail
    466 {
    467   public:
    468     QString   channame;
    469     QString   title;
    470     QString   subtitle;
    471     QDateTime startTime;
    472     QDateTime endTime;
    473 };
    474 typedef vector<ProgramDetail> ProgramDetailList;
    475 
    476475#endif // MYTHPROGRAM_H_
    477476
    478477/* vim: set expandtab tabstop=4 shiftwidth=4: */
  • libs/libmyth/programlist.h

     
    99// of the list while the linked list erase() is always O(1), but all other
    1010// operations are faster with the deque.
    1111
    12 #define PGLIST_USE_LINKED_LIST
     12//#define PGLIST_USE_LINKED_LIST
    1313
    1414// C++ headers
    1515#ifdef PGLIST_USE_LINKED_LIST
     
    2929// MythTV headers
    3030#include "mythexp.h"
    3131#include "mythdbcon.h"
    32 #include "programinfo.h" // for ProgramDetailList
    3332
     33class ProgramList;
     34MPUBLIC bool LoadFromProgram(
     35    ProgramList        &destination,
     36    const QString      &sql,
     37    const MSqlBindings &bindings,
     38    const ProgramList  &schedList,
     39    bool                oneChanid);
     40
     41
     42MPUBLIC bool LoadFromOldRecorded(
     43    ProgramList        &destination,
     44    const QString      &sql,
     45    const MSqlBindings &bindings);
     46
     47MPUBLIC bool LoadFromRecorded(
     48    ProgramList        &destination,
     49    bool                orderDescending,
     50    bool                possiblyInProgressRecordingsOnly,
     51    const ProgramList  &schedList);
     52
     53MPUBLIC bool LoadFromScheduler(
     54    ProgramList        &destination,
     55    bool               &hasConflicts,
     56    QString             altTable = "",
     57    int                 recordid = -1);
     58
     59MPUBLIC bool LoadFromScheduler(ProgramList &destination);
     60
    3461/** \class ProgramList
    3562 *  \brief List of ProgramInfo instances, with helper functions.
    3663 */
    3764class MPUBLIC ProgramList
    3865{
     66    friend class RecordingList;
    3967  public:
    4068    ProgramList(bool auto_delete = true) : autodelete(auto_delete) {}
    4169    ~ProgramList();
     
    4573
    4674    ProgramInfo *operator[](uint index);
    4775    const ProgramInfo *operator[](uint index) const;
    48     bool operator==(const ProgramList &b) const;
    4976
    50     bool FromScheduler(bool    &hasConflicts,
    51                        QString  altTable = "",
    52                        int      recordid = -1);
    53 
    54     bool FromScheduler(void)
    55     {
    56         bool dummyConflicts;
    57         return FromScheduler(dummyConflicts, "", -1);
    58     };
    59 
    60     bool FromProgram(const QString &sql, MSqlBindings &bindings,
    61                      ProgramList &schedList, bool oneChanid = false);
    62 
    63     bool FromProgram(const QString &sql, MSqlBindings &bindings)
    64     {
    65         ProgramList dummySched;
    66         return FromProgram(sql, bindings, dummySched);
    67     }
    68 
    69     bool FromRecorded( bool bDescending, ProgramList *pSchedList);
    70 
    71     bool FromOldRecorded(const QString &sql, MSqlBindings &bindings);
    72 
    73     static bool GetProgramDetailList(
    74         QDateTime         &nextRecordingStart,
    75         bool              *hasConflicts = NULL,
    76         ProgramDetailList *list = NULL);
    77 
    7877    ProgramInfo *take(uint i);
    7978    iterator erase(iterator it);
    8079    void clear(void);
     
    9190    void push_back(ProgramInfo *pginfo) { pglist.push_back(pginfo); }
    9291
    9392    // compatibility with old Q3PtrList
    94     bool isEmpty(void) const { return empty(); }
    95     size_t count(void) const { return size(); }
    96     ProgramInfo *at(uint index) { return (*this)[index]; }
    97     void prepend(ProgramInfo *pginfo) { push_front(pginfo); }
    98     void append(ProgramInfo *pginfo) { push_back(pginfo); }
    9993    void setAutoDelete(bool auto_delete) { autodelete = auto_delete; }
    10094
    10195  protected:
  • libs/libmyth/programinfo.cpp

     
    224224{
    225225}
    226226
     227ProgramInfo::ProgramInfo(
     228    const MSqlQuery &query, const ProgramList &schedList, bool oneChanid)
     229{
     230    if (!query.isValid())
     231    {
     232        ProgramInfo blank;
     233        *this = blank;
     234    }
     235
     236    chanid = query.value(0).toString();
     237    startts = QDateTime::fromString(query.value(1).toString(),
     238                                    Qt::ISODate);
     239    endts = QDateTime::fromString(query.value(2).toString(),
     240                                  Qt::ISODate);
     241    recstartts = startts;
     242    recendts = endts;
     243    lastmodified = startts;
     244    title = query.value(3).toString();
     245    subtitle = query.value(4).toString();
     246    description = query.value(5).toString();
     247    category = query.value(6).toString();
     248    chanstr = query.value(7).toString();
     249    chansign = query.value(8).toString();
     250    channame = query.value(9).toString();
     251    repeat = query.value(10).toInt();
     252    chancommfree = COMM_DETECT_COMMFREE == query.value(11).toInt();
     253    chanOutputFilters = query.value(12).toString();
     254    seriesid = query.value(13).toString();
     255    programid = query.value(14).toString();
     256    year = query.value(15).toString();
     257    stars = query.value(16).toString().toFloat();
     258
     259    if (query.value(17).isNull() || query.value(17).toString().isEmpty())
     260    {
     261        originalAirDate = QDate (0, 1, 1);
     262        hasAirDate = false;
     263    }
     264    else
     265    {
     266        originalAirDate =
     267            QDate::fromString(query.value(17).toString(),Qt::ISODate);
     268
     269        if (originalAirDate > QDate(1940, 1, 1))
     270            hasAirDate = true;
     271        else
     272            hasAirDate = false;
     273    }
     274    catType = query.value(18).toString();
     275    recordid = query.value(19).toInt();
     276    rectype = RecordingType(query.value(20).toInt());
     277    recstatus = RecStatusType(query.value(21).toInt());
     278    findid = query.value(22).toInt();
     279
     280
     281    ProgramList::const_iterator it = schedList.begin();
     282    for (; it != schedList.end(); ++it)
     283    {
     284        if (!IsSameTimeslot(**it))
     285            continue;
     286
     287        const ProgramInfo &s = **it;
     288        recordid    = s.recordid;
     289        recstatus   = s.recstatus;
     290        rectype     = s.rectype;
     291        recpriority = s.recpriority;
     292        recstartts  = s.recstartts;
     293        recendts    = s.recendts;
     294        cardid      = s.cardid;
     295        inputid     = s.inputid;
     296        dupin       = s.dupin;
     297        dupmethod   = s.dupmethod;
     298        findid      = s.findid;
     299
     300        if (s.recstatus == rsWillRecord || s.recstatus == rsRecording)
     301        {
     302            if (oneChanid)
     303            {
     304                chanid   = s.chanid;
     305                chanstr  = s.chanstr;
     306                chansign = s.chansign;
     307                channame = s.channame;
     308            }
     309            else if ((chanid != s.chanid) && (chanstr != s.chanstr))
     310            {
     311                recstatus = rsOtherShowing;
     312            }
     313        }
     314    }
     315}
     316
    227317/** \fn ProgramInfo::operator=(const ProgramInfo &other)
    228318 *  \brief Copies important fields from other ProgramInfo.
    229319 */
     
    9361026    bindings[":STARTTS1"] = str_startts;
    9371027    bindings[":STARTTS2"] = str_startts;
    9381028
    939     schedList.FromScheduler();
    940     progList.FromProgram(querystr, bindings, schedList);
     1029    LoadFromScheduler(schedList);
     1030    LoadFromProgram(progList, querystr, bindings, schedList, false);
    9411031
    942     if (!progList.isEmpty())
     1032    if (!progList.empty())
    9431033    {
    9441034        ProgramInfo *pginfo = progList[0];
    9451035
     
    10161106    bindings[":CHANID"]  = QString::number(_chanid);
    10171107    bindings[":STARTTS"] = dtime.toString("yyyy-MM-ddThh:mm:50");
    10181108
    1019     progList.FromProgram(querystr, bindings, schedList);
     1109    LoadFromProgram(progList, querystr, bindings, schedList, false);
    10201110
    1021     if (!progList.isEmpty())
     1111    if (!progList.empty())
    10221112        nextstart = (*progList.begin())->startts;
    10231113
    10241114    if (nextstart > startts && nextstart < recendts)
  • libs/libmyth/programlist.cpp

     
    55#include "mythdb.h"
    66#include "util.h"
    77#include "programlist.h"
     8#include "programinfo.h"
    89
    910ProgramList::~ProgramList(void)
    1011{
     
    3536    return (*(const_cast<ProgramList*>(this)))[index];
    3637}
    3738
    38 bool ProgramList::operator==(const ProgramList &b) const
    39 {
    40     const_iterator it_a  = pglist.begin();
    41     const_iterator it_b  = b.pglist.begin();
    42     const_iterator end_a = pglist.end();
    43     const_iterator end_b = b.pglist.end();
    44 
    45     for (; it_a != end_a && it_b != end_b; ++it_a, ++it_b)
    46     {
    47         if (*it_a != *it_b)
    48             return false;
    49     }
    50 
    51     return (it_a == end_a) && (it_b == end_b);
    52 }
    53 
    5439ProgramInfo *ProgramList::take(uint index)
    5540{
    5641#ifndef PGLIST_USE_LINKED_LIST
     
    11095#endif
    11196}
    11297
    113 bool ProgramList::FromScheduler(bool &hasConflicts, QString tmptable,
    114                                 int recordid)
    115 {
    116     clear();
    117     hasConflicts = false;
     98//////////////////////////////////////////////////////////////////////
    11899
    119     if (gContext->IsBackend())
    120         return false;
    121 
    122     QString query;
    123     if (tmptable != "")
    124     {
    125         query = QString("QUERY_GETALLPENDING %1 %2")
    126                         .arg(tmptable).arg(recordid);
    127     } else {
    128         query = QString("QUERY_GETALLPENDING");
    129     }
    130 
    131     QStringList slist( query );
    132     if (!gContext->SendReceiveStringList(slist) || slist.size() < 2)
    133     {
    134         VERBOSE(VB_IMPORTANT,
    135                 "ProgramList::FromScheduler(): Error querying master.");
    136         return false;
    137     }
    138 
    139     hasConflicts = slist[0].toInt();
    140 
    141     bool result = true;
    142     QStringList::const_iterator sit = slist.begin()+2;
    143 
    144     while (result && sit != slist.end())
    145     {
    146         ProgramInfo *p = new ProgramInfo();
    147         result = p->FromStringList(sit, slist.end());
    148         if (result)
    149             pglist.push_back(p);
    150         else
    151             delete p;
    152     }
    153 
    154     if (pglist.size() != slist[1].toUInt())
    155     {
    156         VERBOSE(VB_IMPORTANT,
    157                 "ProgramList::FromScheduler(): Length mismatch");
    158         clear();
    159         result = false;
    160     }
    161 
    162     return result;
    163 }
    164 
    165 bool ProgramList::FromProgram(const QString &sql, MSqlBindings &bindings,
    166                               ProgramList &schedList, bool oneChanid)
     100static bool FromProgramQuery(
     101    const QString &sql, const MSqlBindings &bindings, MSqlQuery &query)
    167102{
    168     clear();
    169 
    170103    QString querystr = QString(
    171104        "SELECT DISTINCT program.chanid, program.starttime, program.endtime, "
    172105        "    program.title, program.subtitle, program.description, "
     
    200133    if (!sql.contains(" LIMIT "))
    201134        querystr += " LIMIT 20000 ";
    202135
     136    query.prepare(querystr);
     137    MSqlBindings::const_iterator it;
     138    for (it = bindings.begin(); it != bindings.end(); ++it)
     139    {
     140        if (querystr.contains(it.key()))
     141            query.bindValue(it.key(), it.value());
     142    }
     143
     144    if (!query.exec())
     145    {
     146        MythDB::DBError("LoadFromProgramQuery", query);
     147        return false;
     148    }
     149
     150    return true;
     151}
     152
     153bool LoadFromProgram(
     154    ProgramList &destination,
     155    const QString &sql, const MSqlBindings &bindings,
     156    const ProgramList &schedList, bool oneChanid)
     157{
     158    destination.clear();
     159
    203160    MSqlQuery query(MSqlQuery::InitCon());
     161    if (!FromProgramQuery(sql, bindings, query))
     162        return false;
     163
     164    while (query.next())
     165        destination.push_back(new ProgramInfo(query, schedList, oneChanid));
     166
     167    return true;
     168}
     169
     170bool LoadFromOldRecorded(
     171    ProgramList &destination, const QString &sql, const MSqlBindings &bindings)
     172{
     173    destination.clear();
     174
     175    MSqlQuery query(MSqlQuery::InitCon());
     176   
     177    QString querystr =
     178        "SELECT oldrecorded.chanid, starttime, endtime, "
     179        "       title, subtitle, description, category, seriesid, "
     180        "       programid, channel.channum, channel.callsign, "
     181        "       channel.name, findid, rectype, recstatus, recordid, "
     182        "       duplicate "
     183        " FROM oldrecorded "
     184        " LEFT JOIN channel ON oldrecorded.chanid = channel.chanid "
     185        + sql;
     186
    204187    query.prepare(querystr);
    205188    MSqlBindings::const_iterator it;
    206189    for (it = bindings.begin(); it != bindings.end(); ++it)
     190    {
    207191        if (querystr.contains(it.key()))
    208192            query.bindValue(it.key(), it.value());
     193    }
    209194
    210195    if (!query.exec())
    211196    {
    212         MythDB::DBError("ProgramList::FromProgram", query);
     197        MythDB::DBError("LoadFromOldRecorded", query);
    213198        return false;
    214199    }
    215200
     
    228213        p->subtitle = query.value(4).toString();
    229214        p->description = query.value(5).toString();
    230215        p->category = query.value(6).toString();
    231         p->chanstr = query.value(7).toString();
    232         p->chansign = query.value(8).toString();
    233         p->channame = query.value(9).toString();
    234         p->repeat = query.value(10).toInt();
    235         p->chancommfree = COMM_DETECT_COMMFREE == query.value(11).toInt();
    236         p->chanOutputFilters = query.value(12).toString();
    237         p->seriesid = query.value(13).toString();
    238         p->programid = query.value(14).toString();
    239         p->year = query.value(15).toString();
    240         p->stars = query.value(16).toString().toFloat();
     216        p->seriesid = query.value(7).toString();
     217        p->programid = query.value(8).toString();
     218        p->chanstr = query.value(9).toString();
     219        p->chansign = query.value(10).toString();
     220        p->channame = query.value(11).toString();
     221        p->findid = query.value(12).toInt();
     222        p->rectype = RecordingType(query.value(13).toInt());
     223        p->recstatus = RecStatusType(query.value(14).toInt());
     224        p->recordid = query.value(15).toInt();
     225        p->duplicate = query.value(16).toInt();
    241226
    242         if (query.value(17).isNull() || query.value(17).toString().isEmpty())
    243         {
    244             p->originalAirDate = QDate (0, 1, 1);
    245             p->hasAirDate = false;
    246         }
    247         else
    248         {
    249             p->originalAirDate =
    250                 QDate::fromString(query.value(17).toString(),Qt::ISODate);
    251 
    252             if (p->originalAirDate > QDate(1940, 1, 1))
    253                 p->hasAirDate = true;
    254             else
    255                 p->hasAirDate = false;
    256         }
    257         p->catType = query.value(18).toString();
    258         p->recordid = query.value(19).toInt();
    259         p->rectype = RecordingType(query.value(20).toInt());
    260         p->recstatus = RecStatusType(query.value(21).toInt());
    261         p->findid = query.value(22).toInt();
    262 
    263         iterator it = schedList.pglist.begin();
    264         for (; it != schedList.pglist.end(); ++it)
    265         {
    266             ProgramInfo *s = *it;
    267             if (p->IsSameTimeslot(*s))
    268             {
    269                 p->recordid = s->recordid;
    270                 p->recstatus = s->recstatus;
    271                 p->rectype = s->rectype;
    272                 p->recpriority = s->recpriority;
    273                 p->recstartts = s->recstartts;
    274                 p->recendts = s->recendts;
    275                 p->cardid = s->cardid;
    276                 p->inputid = s->inputid;
    277                 p->dupin = s->dupin;
    278                 p->dupmethod = s->dupmethod;
    279                 p->findid = s->findid;
    280 
    281                 if (s->recstatus == rsWillRecord ||
    282                     s->recstatus == rsRecording)
    283                 {
    284                     if (oneChanid)
    285                     {
    286                         p->chanid   = s->chanid;
    287                         p->chanstr  = s->chanstr;
    288                         p->chansign = s->chansign;
    289                         p->channame = s->channame;
    290                     }
    291                     else if ((p->chanid != s->chanid) &&
    292                              (p->chanstr != s->chanstr))
    293                     {
    294                         p->recstatus = rsOtherShowing;
    295                     }
    296                 }
    297             }
    298         }
    299 
    300         pglist.push_back(p);
     227        destination.push_back(p);
    301228    }
    302229
    303230    return true;
    304231}
    305232
    306 bool ProgramList::FromRecorded( bool bDescending, ProgramList *pSchedList )
     233bool LoadFromRecorded(
     234    ProgramList &destination,
     235    bool orderDescending,
     236    bool possiblyInProgressTecordingsOnly,
     237    const ProgramList &schedList)
    307238{
    308     clear();
     239    destination.clear();
    309240
    310241    QString     fs_db_name = "";
    311242    QDateTime   rectime    = QDateTime::currentDateTime().addSecs(
     
    317248    // ----------------------------------------------------------------------
    318249
    319250    QMap<QString, int> inUseMap;
     251    QString   inUseKey;
     252    QString   inUseForWhat;
     253    QDateTime oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
    320254
    321     QString     inUseKey;
    322     QString     inUseForWhat;
    323     QDateTime   oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
     255    MSqlQuery query(MSqlQuery::InitCon());
    324256
    325     MSqlQuery   query(MSqlQuery::InitCon());
    326 
    327257    query.prepare("SELECT DISTINCT chanid, starttime, recusage "
    328258                  " FROM inuseprograms WHERE lastupdatetime >= :ONEHOURAGO ;");
    329259    query.bindValue(":ONEHOURAGO", oneHourAgo);
     
    341271
    342272            if ((inUseForWhat == "player") ||
    343273                (inUseForWhat == "preview player") ||
    344                 (inUseForWhat == "PIP player"))
     274                (inUseForWhat == "pipplayer") ||
     275                (inUseForWhat == "pbpplayer"))
    345276                inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSEPLAYING;
    346277            else if (inUseForWhat == "recorder")
    347278                inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSERECORDING;
     
    380311        "recorded.hostname,channum,name,callsign,commflagged,cutlist,"
    381312        "recorded.autoexpire,editing,bookmark,recorded.category,"
    382313        "recorded.recgroup,record.dupin,record.dupmethod,"
    383         "record.recordid,outputfilters,"
     314        "recorded.recordid,channel.outputfilters,"
    384315        "recorded.seriesid,recorded.programid,recorded.filesize, "
    385316        "recorded.lastmodified, recorded.findid, "
    386317        "recorded.originalairdate, recorded.playgroup, "
     
    388319        "recorded.progend, recorded.stars, "
    389320        "recordedprogram.audioprop+0, recordedprogram.videoprop+0, "
    390321        "recordedprogram.subtitletypes+0, recorded.watched, "
    391         "recorded.storagegroup "
     322        "recorded.storagegroup, "
     323        "recorded.transcoded, recorded.recpriority, "
     324        "recorded.preserve, recordedprogram.airdate "
    392325        "FROM recorded "
    393326        "LEFT JOIN record ON recorded.recordid = record.recordid "
    394327        "LEFT JOIN channel ON recorded.chanid = channel.chanid "
     
    396329        " ( recorded.chanid    = recordedprogram.chanid AND "
    397330        "   recorded.progstart = recordedprogram.starttime ) "
    398331        "WHERE ( recorded.deletepending = 0 OR "
    399         "        recorded.lastmodified <= DATE_SUB(NOW(), INTERVAL 5 MINUTE) "
    400         "      ) "
    401         "ORDER BY recorded.starttime";
     332        "        DATE_ADD(recorded.lastmodified, INTERVAL 5 MINUTE) <= NOW() "
     333        "      ) ";
    402334
    403     if ( bDescending )
    404         thequery += " DESC";
     335    if (possiblyInProgressTecordingsOnly)
     336    {
     337        thequery +=
     338            " AND recorded.endtime   >= NOW() "
     339            " AND recorded.starttime <= NOW() ";
     340    }
    405341
     342    thequery += "ORDER BY recorded.starttime";
     343    thequery += (orderDescending) ? " DESC " : "";
     344
    406345    QString chanorder = gContext->GetSetting("ChannelOrdering", "channum");
    407346    if (chanorder != "channum")
    408347        thequery += ", " + chanorder;
     
    449388        }
    450389        else
    451390        {
    452             proginfo->originalAirDate =
    453                 QDate::fromString(query.value(26).toString(),Qt::ISODate);
    454 
    455             if (proginfo->originalAirDate > QDate(1940, 1, 1))
    456                 proginfo->hasAirDate  = true;
    457             else
    458                 proginfo->hasAirDate  = false;
     391            QDate oad = QDate::fromString(
     392                query.value(26).toString(), Qt::ISODate);
     393            proginfo->originalAirDate = oad;
     394            proginfo->hasAirDate = oad.isValid() && (oad > QDate(1940, 1, 1));
    459395        }
    460396
    461397        proginfo->pathname = query.value(28).toString();
    462398
    463 
    464         if (proginfo->hostname.isEmpty() || proginfo->hostname.isNull())
     399        if (proginfo->hostname.isEmpty())
    465400            proginfo->hostname = gContext->GetHostName();
    466401
    467402        if (!query.value(7).toString().isEmpty())
     
    484419        flags |=  query.value(12).toInt()                 ? FL_AUTOEXP  : 0;
    485420        flags |= (query.value(14).toInt() == 1)           ? FL_BOOKMARK : 0;
    486421        flags |= (query.value(35).toInt() == 1)           ? FL_WATCHED  : 0;
     422        flags |= (query.value(37).toInt() == TRANSCODING_COMPLETE) ?
     423            FL_TRANSCODED : 0;
     424        flags |= (query.value(39).toInt() == 1)           ? FL_PRESERVED: 0;
    487425
    488426        inUseKey = query.value(0).toString() + " " +
    489427            query.value(1).toDateTime().toString(Qt::ISODate);
     
    520458        proginfo->playgroup    = query.value(27).toString();
    521459        proginfo->storagegroup = query.value(36).toString();
    522460        proginfo->recstatus    = rsRecorded;
     461        proginfo->recpriority  = query.value(38).toInt();
     462        proginfo->year         = query.value(40).toString();
    523463
    524         if ((pSchedList != NULL) && (proginfo->recendts > rectime))
     464        if (proginfo->recendts > rectime)
    525465        {
    526             iterator it = pSchedList->pglist.begin();
    527             for (; it != pSchedList->pglist.end(); ++it)
     466            ProgramList::const_iterator it = schedList.begin();
     467            for (; it != schedList.end(); ++it)
    528468            {
    529                 ProgramInfo *s = *it;
    530                 if (s && s->recstatus    == rsRecording &&
    531                     proginfo->chanid     == s->chanid   &&
    532                     proginfo->recstartts == s->recstartts)
     469                const ProgramInfo &s = **it;
     470                if (s.recstatus          == rsRecording &&
     471                    proginfo->chanid     == s.chanid    &&
     472                    proginfo->recstartts == s.recstartts)
    533473                {
    534474                    proginfo->recstatus = rsRecording;
    535475                    break;
     
    539479
    540480        proginfo->stars = query.value(31).toDouble();
    541481
    542         pglist.push_back(proginfo);
     482        destination.push_back(proginfo);
    543483    }
    544484
    545485    return true;
    546486}
    547487
    548 
    549 bool ProgramList::FromOldRecorded(const QString &sql, MSqlBindings &bindings)
     488bool LoadFromScheduler(
     489    ProgramList &destination, bool &hasConflicts,
     490    QString tmptable, int recordid)
    550491{
    551     clear();
    552     MSqlQuery query(MSqlQuery::InitCon());
     492    destination.clear();
     493    hasConflicts = false;
    553494
    554     query.prepare("SELECT oldrecorded.chanid, starttime, endtime, "
    555                   " title, subtitle, description, category, seriesid, "
    556                   " programid, channel.channum, channel.callsign, "
    557                   " channel.name, findid, rectype, recstatus, recordid, "
    558                   " duplicate "
    559                   " FROM oldrecorded "
    560                   " LEFT JOIN channel ON oldrecorded.chanid = channel.chanid "
    561                   + sql);
    562     query.bindValues(bindings);
     495    if (gContext->IsBackend())
     496        return false;
    563497
    564     if (!query.exec() || !query.isActive())
     498    QString query;
     499    if (!tmptable.isEmpty())
    565500    {
    566         MythDB::DBError("ProgramList::FromOldRecorded", query);
    567         return false;
     501        query = QString("QUERY_GETALLPENDING %1 %2")
     502            .arg(tmptable).arg(recordid);
    568503    }
    569 
    570     while (query.next())
     504    else
    571505    {
    572         ProgramInfo *p = new ProgramInfo;
    573         p->chanid = query.value(0).toString();
    574         p->startts = QDateTime::fromString(query.value(1).toString(),
    575                                            Qt::ISODate);
    576         p->endts = QDateTime::fromString(query.value(2).toString(),
    577                                          Qt::ISODate);
    578         p->recstartts = p->startts;
    579         p->recendts = p->endts;
    580         p->lastmodified = p->startts;
    581         p->title = query.value(3).toString();
    582         p->subtitle = query.value(4).toString();
    583         p->description = query.value(5).toString();
    584         p->category = query.value(6).toString();
    585         p->seriesid = query.value(7).toString();
    586         p->programid = query.value(8).toString();
    587         p->chanstr = query.value(9).toString();
    588         p->chansign = query.value(10).toString();
    589         p->channame = query.value(11).toString();
    590         p->findid = query.value(12).toInt();
    591         p->rectype = RecordingType(query.value(13).toInt());
    592         p->recstatus = RecStatusType(query.value(14).toInt());
    593         p->recordid = query.value(15).toInt();
    594         p->duplicate = query.value(16).toInt();
     506        query = QString("QUERY_GETALLPENDING");
     507    }
    595508
    596         pglist.push_back(p);
     509    QStringList slist( query );
     510    if (!gContext->SendReceiveStringList(slist) || slist.size() < 2)
     511    {
     512        VERBOSE(VB_IMPORTANT,
     513                "LoadFromScheduler(): Error querying master.");
     514        return false;
    597515    }
    598516
    599     return true;
    600 }
     517    hasConflicts = slist[0].toInt();
    601518
    602 bool ProgramList::GetProgramDetailList(
    603     QDateTime &nextRecordingStart, bool *hasConflicts, ProgramDetailList *list)
    604 {
    605     nextRecordingStart = QDateTime();
     519    bool result = true;
     520    QStringList::const_iterator sit = slist.begin()+2;
    606521
    607     bool dummy;
    608     bool *conflicts = (hasConflicts) ? hasConflicts : &dummy;
    609 
    610     ProgramList progList;
    611     if (!progList.FromScheduler(*conflicts))
    612         return false;
    613 
    614     // find the earliest scheduled recording
    615     ProgramList::const_iterator it = progList.begin();
    616     for (; it != progList.end(); ++it)
     522    while (result && sit != slist.end())
    617523    {
    618         if (((*it)->recstatus == rsWillRecord) &&
    619             (nextRecordingStart.isNull() ||
    620              nextRecordingStart > (*it)->recstartts))
    621         {
    622             nextRecordingStart = (*it)->recstartts;
    623         }
     524        ProgramInfo *p = new ProgramInfo();
     525        result = p->FromStringList(sit, slist.end());
     526        if (result)
     527            destination.push_back(p);
     528        else
     529            delete p;
    624530    }
    625531
    626     if (!list)
    627         return true;
    628 
    629     // save the details of the earliest recording(s)
    630     for (it = progList.begin(); it != progList.end(); ++it)
     532    if (destination.size() != slist[1].toUInt())
    631533    {
    632         if (((*it)->recstatus  == rsWillRecord) &&
    633             ((*it)->recstartts == nextRecordingStart))
    634         {
    635             ProgramDetail prog;
    636             prog.channame  = (*it)->channame;
    637             prog.title     = (*it)->title;
    638             prog.subtitle  = (*it)->subtitle;
    639             prog.startTime = (*it)->recstartts;
    640             prog.endTime   = (*it)->recendts;
    641             list->push_back(prog);
    642         }
     534        VERBOSE(VB_IMPORTANT,
     535                "LoadFromScheduler(): Length mismatch.");
     536        destination.clear();
     537        result = false;
    643538    }
    644539
    645     return true;
     540    return result;
    646541}
     542
     543bool LoadFromScheduler(ProgramList &destination)
     544{
     545    bool dummyConflicts;
     546    return LoadFromScheduler(destination, dummyConflicts, "", -1);
     547}
  • programs/mythfrontend/playbackbox.cpp

     
    11021102
    11031103    if (m_noRecordingsText)
    11041104    {
    1105         if (!progList.isEmpty())
     1105        if (!progList.empty())
    11061106            m_noRecordingsText->SetVisible(false);
    11071107        else
    11081108        {
     
    12491249
    12501250                if (m_viewMask != VIEW_NONE &&
    12511251                    (p->recgroup != "LiveTV" || m_recGroup == "LiveTV"))
    1252                     m_progLists[""].prepend(p);
     1252                    m_progLists[""].push_front(p);
    12531253
    12541254                asKey = p->MakeUniqueKey();
    12551255                if (asCache.contains(asKey))
     
    12631263                {
    12641264                    QString tmpTitle = tr("LiveTV");
    12651265                    sortedList[tmpTitle.toLower()] = tmpTitle;
    1266                     m_progLists[tmpTitle.toLower()].prepend(p);
     1266                    m_progLists[tmpTitle.toLower()].push_front(p);
    12671267                    m_progLists[tmpTitle.toLower()].setAutoDelete(false);
    12681268                    continue;
    12691269                }
     
    12771277
    12781278                    if (!sortedList.contains(sTitle))
    12791279                        sortedList[sTitle] = p->title;
    1280                     m_progLists[sortedList[sTitle].toLower()].prepend(p);
     1280                    m_progLists[sortedList[sTitle].toLower()].push_front(p);
    12811281                    m_progLists[sortedList[sTitle].toLower()].setAutoDelete(false);
    12821282                }
    12831283
     
    12851285                    !p->recgroup.isEmpty()) // Show recording groups
    12861286                {
    12871287                    sortedList[p->recgroup.toLower()] = p->recgroup;
    1288                     m_progLists[p->recgroup.toLower()].prepend(p);
     1288                    m_progLists[p->recgroup.toLower()].push_front(p);
    12891289                    m_progLists[p->recgroup.toLower()].setAutoDelete(false);
    12901290                }
    12911291
     
    12931293                    !p->category.isEmpty()) // Show categories
    12941294                {
    12951295                    sortedList[p->category.toLower()] = p->category;
    1296                     m_progLists[p->category.toLower()].prepend(p);
     1296                    m_progLists[p->category.toLower()].push_front(p);
    12971297                    m_progLists[p->category.toLower()].setAutoDelete(false);
    12981298                }
    12991299
     
    13041304                    QString tmpTitle = QString("(%1)")
    13051305                                               .arg(searchRule[p->recordid]);
    13061306                    sortedList[tmpTitle.toLower()] = tmpTitle;
    1307                     m_progLists[tmpTitle.toLower()].prepend(p);
     1307                    m_progLists[tmpTitle.toLower()].push_front(p);
    13081308                    m_progLists[tmpTitle.toLower()].setAutoDelete(false);
    13091309                }
    13101310
     
    13291329                        if (recidEpisodes[p->recordid] == 1 ||
    13301330                            p->recordid == 0 )
    13311331                        {
    1332                             m_progLists[m_watchGroupLabel].prepend(p);
     1332                            m_progLists[m_watchGroupLabel].push_front(p);
    13331333                            m_progLists[m_watchGroupLabel].setAutoDelete(false);
    13341334                        }
    13351335                        else
     
    40644064    }
    40654065
    40664066    // Create and add the "All Programs" entry
    4067     displayNames.prepend(tr("%1 [%n item(s)]", 0, totalItems)
    4068                          .arg(ProgramInfo::i18n("All Programs")));
    4069     groupNames.prepend("All Programs");
     4067    displayNames.push_front(tr("%1 [%n item(s)]", 0, totalItems)
     4068                            .arg(ProgramInfo::i18n("All Programs")));
     4069    groupNames.push_front("All Programs");
    40704070    m_recGroupType["All Programs"] = "recgroup";
    40714071
    40724072    // Find each category, and the number of recordings in each
  • programs/mythfrontend/guidegrid.cpp

     
    283283    m_channelCount = min(m_channelCount, maxchannel + 1);
    284284    updateChannels();
    285285
    286     m_recList.FromScheduler();
     286    LoadFromScheduler(m_recList);
    287287    fillProgramInfos();
    288288    updateInfo();
    289289
     
    616616    bindings[":CHANID"]  = chanid;
    617617
    618618    ProgramList dummy;
    619     proglist.FromProgram(querystr, bindings, dummy);
     619    LoadFromProgram(proglist,querystr, bindings, dummy, false);
    620620
    621621    return proglist;
    622622}
     
    10061006    bindings[":STARTTS"] = m_currentStartTime.toString("yyyy-MM-ddThh:mm:00");
    10071007    bindings[":ENDTS"] = m_currentEndTime.toString("yyyy-MM-ddThh:mm:00");
    10081008
    1009     proglist->FromProgram(querystr, bindings, m_recList);
     1009    LoadFromProgram(*proglist, querystr, bindings, m_recList, false);
    10101010
    10111011    QDateTime ts = m_currentStartTime;
    10121012
     
    10781078
    10791079    vector<ProgramInfo*>::iterator it = unknownlist.begin();
    10801080    for (; it != unknownlist.end(); ++it)
    1081         proglist->append(*it);
     1081        proglist->push_back(*it);
    10821082
    10831083    MythRect programRect = m_guideGrid->GetArea();
    10841084
     
    12221222
    12231223        if (message == "SCHEDULE_CHANGE")
    12241224        {
    1225             m_recList.FromScheduler();
     1225            LoadFromScheduler(m_recList);
    12261226            fillProgramInfos();
    12271227            updateInfo();
    12281228        }
     
    15281528    maxchannel = max((int)GetChannelCount() - 1, 0);
    15291529    m_channelCount = min(m_guideGrid->getChannelCount(), maxchannel + 1);
    15301530
    1531     m_recList.FromScheduler();
     1531    LoadFromScheduler(m_recList);
    15321532    fillProgramInfos();
    15331533}
    15341534
     
    19141914    ri.ToggleRecord();
    19151915    *pginfo = ri;
    19161916
    1917     m_recList.FromScheduler();
     1917    LoadFromScheduler(m_recList);
    19181918    fillProgramInfos();
    19191919    updateInfo();
    19201920}
  • programs/mythfrontend/progfind.h

     
    11#ifndef PROGFIND_H_
    22#define PROGFIND_H_
    33
    4 // qt
     4// Qt
    55#include <QDateTime>
    66#include <QEvent>
    77
    8 // myth
     8// MythTV
    99#include "mythscreentype.h"
    1010#include "programlist.h"
    1111#include "mythdialogbox.h"
     12#include "playercontext.h"
    1213
    1314// mythfrontend
    1415#include "schedulecommon.h"
  • programs/mythfrontend/viewscheduled.cpp

     
    256256
    257257    m_recgroupList.clear();
    258258
    259     m_recList.FromScheduler(m_conflictBool);
     259    LoadFromScheduler(m_recList, m_conflictBool);
    260260
    261261    ProgramList::iterator pit = m_recList.begin();
    262262    QString currentDate;
     
    284284                m_maxinput = pginfo->inputid;
    285285
    286286            QDate date = (pginfo->recstartts).date();
    287             m_recgroupList[date].append(pginfo);
     287            m_recgroupList[date].push_back(pginfo);
    288288            m_recgroupList[date].setAutoDelete(false);
    289289
    290             m_recgroupList[m_defaultGroup].append(pginfo);
     290            m_recgroupList[m_defaultGroup].push_back(pginfo);
    291291
    292292            ++pit;
    293293        }
     
    329329
    330330        plist = m_recgroupList[m_currentGroup];
    331331
    332         int listPos = plist.count() - 1;
     332        int listPos = ((int) plist.size()) - 1;
    333333        int i;
    334334        for (i = listPos; i >= 0; --i)
    335335        {
     
    353353
    354354void ViewScheduled::ChangeGroup(MythUIButtonListItem* item)
    355355{
    356     if (!item || m_recList.isEmpty())
     356    if (!item || m_recList.empty())
    357357        return;
    358358
    359359    QDate group = qVariantValue<QDate>(item->GetData());
     
    372372                                                (GetChild("norecordings_info"));
    373373
    374374    if (norecordingText)
    375         norecordingText->SetVisible(m_recList.isEmpty());
     375        norecordingText->SetVisible(m_recList.empty());
    376376
    377     if (m_recList.isEmpty())
     377    if (m_recList.empty())
    378378        return;
    379379
    380380    ProgramList plist;
  • programs/mythfrontend/statusbox.cpp

     
    624624    }
    625625
    626626    ProgramList schedList;
    627     schedList.FromScheduler();
     627    LoadFromScheduler(schedList);
    628628
    629     tmpstr = tr("%n matching showing(s)", "", schedList.count());
     629    tmpstr = tr("%n matching showing(s)", "", schedList.size());
    630630    AddLogLine(tmpstr, tmpstr);
    631631
    632632    ProgramList::const_iterator it = schedList.begin();
  • programs/mythfrontend/proglist.cpp

     
    88#include <algorithm>
    99using namespace std;
    1010
    11 // qt
     11// Qt
    1212#include <QApplication>
    1313#include <QRegExp>
    1414
    15 // libmyth
     15// MythTV
    1616#include "mythcontext.h"
    1717#include "remoteutil.h"
    18 
    19 // libmythtv
    2018#include "scheduledrecording.h"
    2119#include "recordingrule.h"
    2220#include "channelutil.h"
    2321#include "recordinginfo.h"
    24 
    25 // libmythdb
    2622#include "mythdb.h"
    2723#include "mythdbcon.h"
    2824#include "mythverbose.h"
    29 
    30 // libmythui
    3125#include "mythuitext.h"
    3226#include "mythuibutton.h"
    3327#include "mythuibuttonlist.h"
     
    282276        menuPopup->AddButton(tr("Upcoming"));
    283277        menuPopup->AddButton(tr("Custom Edit"));
    284278
    285         ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     279        ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    286280        if (m_type != plPreviouslyRecorded)
    287281        {
    288282            if (pi && pi->recordid > 0)
     
    605599
    606600void ProgLister::quickRecord()
    607601{
    608     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     602    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    609603
    610604    if (!pi)
    611605        return;
     
    617611
    618612void ProgLister::select()
    619613{
    620     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     614    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    621615
    622616    if (!pi)
    623617        return;
     
    630624
    631625void ProgLister::edit()
    632626{
    633     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     627    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    634628
    635629    EditScheduled(pi);
    636630}
    637631
    638632void ProgLister::customEdit()
    639633{
    640     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     634    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    641635
    642636    EditCustom(pi);
    643637}
     
    652646
    653647void ProgLister::deleteRule()
    654648{
    655     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     649    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    656650
    657651    if (!pi || pi->recordid <= 0)
    658652        return;
     
    683677
    684678void ProgLister::deleteOldEpisode()
    685679{
    686     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     680    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    687681
    688682    if (!pi)
    689683        return;
     
    698692    if (!ok)
    699693        return;
    700694
    701     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     695    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    702696
    703697    if (!pi)
    704698        return;
     
    717711
    718712void ProgLister::deleteOldTitle()
    719713{
    720     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     714    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    721715
    722716    if (!pi)
    723717        return;
     
    732726    if (!ok)
    733727        return;
    734728
    735     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     729    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    736730
    737731    if (!pi)
    738732        return;
     
    749743
    750744void ProgLister::oldRecordedActions()
    751745{
    752     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     746    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    753747
    754748    if (!pi)
    755749        return;
     
    790784
    791785void ProgLister::upcoming()
    792786{
    793     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     787    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    794788
    795789    if (!pi || m_type == plTitle)
    796790        return;
     
    800794
    801795void ProgLister::details()
    802796{
    803     ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     797    ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    804798
    805799    ShowDetails(pi);
    806800}
     
    14111405    }
    14121406
    14131407    if (m_type == plPreviouslyRecorded)
    1414         m_itemList.FromOldRecorded(where, bindings);
     1408    {
     1409        LoadFromOldRecorded(m_itemList, where, bindings);
     1410    }
    14151411    else
    14161412    {
    1417         m_schedList.FromScheduler();
    1418         m_itemList.FromProgram(where, bindings, m_schedList, oneChanid);
     1413        LoadFromScheduler(m_schedList);
     1414        LoadFromProgram(m_itemList, where, bindings, m_schedList, oneChanid);
    14191415    }
    14201416
    14211417    ProgramInfo *s;
     
    14691465    {
    14701466        vector<ProgramInfo *>::reverse_iterator r = sortedList.rbegin();
    14711467        for (; r != sortedList.rend(); r++)
    1472             m_itemList.append(*r);
     1468            m_itemList.push_back(*r);
    14731469    }
    14741470    else
    14751471    {
    14761472        vector<ProgramInfo *>::iterator i = sortedList.begin();
    14771473        for (; i != sortedList.end(); ++i)
    1478             m_itemList.append(*i);
     1474            m_itemList.push_back(*i);
    14791475    }
    14801476
    14811477    if (m_messageText)
    1482         m_messageText->SetVisible((m_itemList.count() == 0));
     1478        m_messageText->SetVisible(m_itemList.empty());
    14831479
    14841480    InfoMap infoMap;
    14851481    ProgramInfo pginfo;
     
    15021498            comp = new plTitleSort();
    15031499
    15041500        int i;
    1505         for (i = m_itemList.count() - 2; i >= 0; i--)
     1501        for (i = m_itemList.size() - 2; i >= 0; i--)
    15061502        {
    15071503            bool dobreak;
    15081504            if (m_reverseSort)
     
    16841680        {
    16851681            if (resulttext == tr("Allow this episode to re-record"))
    16861682            {
    1687                 ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     1683                ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    16881684                if (pi)
    16891685                {
    16901686                    RecordingInfo ri(*pi);
     
    16941690            }
    16951691            else if (resulttext == tr("Never record this episode"))
    16961692            {
    1697                 ProgramInfo *pi = m_itemList.at(m_progList->GetCurrentPos());
     1693                ProgramInfo *pi = m_itemList[m_progList->GetCurrentPos()];
    16981694                if (pi)
    16991695                {
    17001696                    RecordingInfo ri(*pi);
  • programs/mythfrontend/programrecpriority.cpp

     
    12431243    m_nowMatch.clear();
    12441244    m_recMatch.clear();
    12451245    ProgramList schedList;
    1246     schedList.FromScheduler();
     1246    LoadFromScheduler(schedList);
    12471247    QDateTime now = QDateTime::currentDateTime();
    12481248
    12491249    ProgramList::const_iterator it = schedList.begin();
  • programs/mythfrontend/progfind.cpp

     
    1 
    2 #include "progfind.h"
    3 
    4 // qt
     1// Qt
    52#include <QDateTime>
    63#include <QApplication>
    74#include <QStringList>
     
    96#include <QKeyEvent>
    107#include <QEvent>
    118
    12 // libmythdb
     9// MythTV
    1310#include "oldsettings.h"
    1411#include "mythdb.h"
    1512#include "mythdbcon.h"
    1613#include "mythdirs.h"
    17 
    18 // libmyth
    1914#include "mythcontext.h"
    20 
    21 // libmythtv
    2215#include "recordinginfo.h"
    2316#include "tv.h"
    24 
    25 // libmythui
    2617#include "mythuitext.h"
    2718#include "mythuitextedit.h"
    2819#include "mythuibuttonlist.h"
     
    3324#include "guidegrid.h"
    3425#include "proglist.h"
    3526#include "customedit.h"
     27#include "progfind.h"
    3628
    3729#define LOC      QString("ProgFinder: ")
    3830#define LOC_ERR  QString("ProgFinder, Error: ")
     
    573565
    574566    QDateTime progStart = QDateTime::currentDateTime();
    575567
    576     m_schedList.FromScheduler();
    577 
    578568    MSqlBindings bindings;
    579569    QString querystr = "WHERE program.title = :TITLE "
    580570                       "  AND program.endtime > :ENDTIME ";
    581571    bindings[":TITLE"] = progTitle;
    582572    bindings[":ENDTIME"] = progStart.toString("yyyy-MM-ddThh:mm:50");
    583573
    584     m_showData.FromProgram(querystr, bindings, m_schedList);
     574    LoadFromScheduler(m_schedList);
     575    LoadFromProgram(m_showData, querystr, bindings, m_schedList, false);
    585576
    586577    updateTimesList();
    587578
  • programs/mythbackend/mythxml.cpp

     
    571571    for (RecIter itRecList =  recList.begin();
    572572                 itRecList != recList.end();   itRecList++)
    573573    {
    574         schedList.append( *itRecList );
     574        schedList.push_back( *itRecList );
    575575    }
    576576
    577577    // ----------------------------------------------------------------------
    578578
    579579    ProgramList progList;
     580    LoadFromProgram( progList, sSQL, bindings, schedList, false );
    580581
    581     progList.FromProgram( sSQL, bindings, schedList );
    582 
    583582    // Build Response
    584583
    585584    QDomDocument doc;
     
    623622    list.push_back( NameValue( "NumOfChannels", iChanCount   ));
    624623    list.push_back( NameValue( "Details"      , bDetails     ));
    625624
    626     list.push_back( NameValue( "Count"        , (int)progList.count() ));
     625    list.push_back( NameValue( "Count"        , (int)progList.size() ));
    627626    list.push_back( NameValue( "AsOf"         , QDateTime::currentDateTime()
    628627                                                .toString( Qt::ISODate )));
    629628    list.push_back( NameValue( "Version"      , MYTH_BINARY_VERSION ));
     
    684683    for (RecIter itRecList =  recList.begin();
    685684                 itRecList != recList.end();   itRecList++)
    686685    {
    687         schedList.append( *itRecList );
     686        schedList.push_back( *itRecList );
    688687    }
    689688
    690689    // ----------------------------------------------------------------------
    691690
    692691    ProgramList progList;
     692    LoadFromProgram( progList, sSQL, bindings, schedList, false );
    693693
    694     progList.FromProgram( sSQL, bindings, schedList );
    695 
    696694    ProgramList::iterator pgit = progList.begin();
    697695
    698696    if (pgit == progList.end())
     
    971969    for (RecIter itRecList =  recList.begin();
    972970                 itRecList != recList.end();   itRecList++)
    973971    {
    974         schedList.append( *itRecList );
     972        schedList.push_back( *itRecList );
    975973    }
    976974
    977975    // ----------------------------------------------------------------------
    978976
    979977    ProgramList progList;
     978    LoadFromRecorded( progList, bDescending, false, schedList );
    980979
    981     progList.FromRecorded( bDescending, &schedList );
    982 
    983980    // Build Response XML
    984981
    985982    QDomDocument doc;
     
    995992
    996993    NameValues list;
    997994
    998     list.push_back( NameValue( "Count"    , (int)progList.count()));
     995    list.push_back( NameValue( "Count"    , (int)progList.size()));
    999996    list.push_back( NameValue( "AsOf"     , QDateTime::currentDateTime()
    1000997                                            .toString( Qt::ISODate )));
    1001998    list.push_back( NameValue( "Version"  , MYTH_BINARY_VERSION ));
  • programs/mythbackend/mainserver.cpp

     
    10771077            {
    10781078                if (!pinfo.FromStringList(sit, slist.end()))
    10791079                    break;
    1080                 slavelist.append(new RecordingInfo(pinfo));
     1080                slavelist.push_back(new RecordingInfo(pinfo));
    10811081            }
    10821082            m_sched->SlaveConnected(slavelist);
    10831083        }
     
    12761276    MythSocket *pbssock = pbs->getSocket();
    12771277    QString playbackhost = pbs->getHostname();
    12781278
    1279     QString fs_db_name = "";
    1280 
    1281     QDateTime rectime = QDateTime::currentDateTime().addSecs(
    1282                             -gContext->GetNumSetting("RecordOverTime"));
    1283     RecIter ri;
    1284     RecList schedList;
     1279    RecList rlSchedList;
    12851280    if (m_sched)
    1286         m_sched->getAllPending(&schedList);
     1281        m_sched->getAllPending(&rlSchedList);
     1282    ProgramList schedList;
     1283    while (!rlSchedList.empty())
     1284    {
     1285        schedList.push_front(rlSchedList.front());
     1286        rlSchedList.pop_front();
     1287    }
    12871288
    1288     QString ip = gContext->GetSetting("BackendServerIP");
    1289     QString port = gContext->GetSetting("BackendServerPort");
     1289    ProgramList destination;
     1290    LoadFromRecorded(
     1291        destination, (type == "Delete"), (type == "Recording"), schedList);
    12901292
    1291     QMap<QString, int> inUseMap;
    1292     QString inUseKey;
    1293     QString inUseForWhat;
    1294     QDateTime oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
    1295 
    1296     MSqlQuery query(MSqlQuery::InitCon());
    1297 
    1298     query.prepare("SELECT DISTINCT chanid, starttime, recusage "
    1299                   " FROM inuseprograms WHERE lastupdatetime >= :ONEHOURAGO ;");
    1300     query.bindValue(":ONEHOURAGO", oneHourAgo);
    1301 
    1302     if (query.exec() && query.isActive() && query.size() > 0)
    1303         while (query.next())
    1304         {
    1305             inUseKey = query.value(0).toString() + " " +
    1306                        query.value(1).toDateTime().toString(Qt::ISODate);
    1307             inUseForWhat = query.value(2).toString();
    1308 
    1309             if (!inUseMap.contains(inUseKey))
    1310                 inUseMap[inUseKey] = 0;
    1311 
    1312             if ((inUseForWhat == "player") ||
    1313                 (inUseForWhat == "preview player") ||
    1314                 (inUseForWhat == "pipplayer") ||
    1315                 (inUseForWhat == "pbpplayer"))
    1316                 inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSEPLAYING;
    1317             else if (inUseForWhat == "recorder")
    1318                 inUseMap[inUseKey] = inUseMap[inUseKey] | FL_INUSERECORDING;
    1319         }
    1320 
    1321 
    1322     QString thequery =
    1323         "SELECT recorded.chanid,recorded.starttime,recorded.endtime,"
    1324         "recorded.title,recorded.subtitle,recorded.description,"
    1325         "recorded.hostname,channum,name,callsign,commflagged,cutlist,"
    1326         "recorded.autoexpire,editing,bookmark,recorded.category,"
    1327         "recorded.recgroup,record.dupin,record.dupmethod,"
    1328         "recorded.recordid,channel.outputfilters,"
    1329         "recorded.seriesid,recorded.programid,recorded.filesize, "
    1330         "recorded.lastmodified, recorded.findid, "
    1331         "recorded.originalairdate, recorded.playgroup, "
    1332         "recorded.basename, recorded.progstart, "
    1333         "recorded.progend, recorded.stars, "
    1334         "recordedprogram.audioprop+0, recordedprogram.videoprop+0, "
    1335         "recordedprogram.subtitletypes+0, transcoded, "
    1336         "recorded.recpriority, watched, recorded.preserve, "
    1337         "recorded.storagegroup, recordedprogram.airdate "
    1338         "FROM recorded "
    1339         "LEFT JOIN record ON recorded.recordid = record.recordid "
    1340         "LEFT JOIN channel ON recorded.chanid = channel.chanid "
    1341         "LEFT JOIN recordedprogram ON "
    1342         " ( recorded.chanid = recordedprogram.chanid AND "
    1343         "  recorded.progstart = recordedprogram.starttime ) "
    1344         "WHERE ( recorded.deletepending = 0 OR "
    1345         "        DATE_ADD(recorded.lastmodified, INTERVAL 5 MINUTE) <= NOW() "
    1346         "      ) ";
    1347 
    1348     if (type == "Recording")
    1349         thequery += "AND recorded.endtime >= NOW() AND "
    1350             "recorded.starttime <= NOW()";
    1351 
    1352     thequery += "ORDER BY recorded.starttime";
    1353 
    1354     if (type == "Delete")
    1355         thequery += " DESC";
    1356 
    1357     QString chanorder = gContext->GetSetting("ChannelOrdering", "channum");
    1358     if (chanorder != "channum")
    1359         thequery += ", " + chanorder;
    1360     else // approximation which the DB can handle
    1361         thequery += ",atsc_major_chan,atsc_minor_chan,channum,callsign";
    1362 
    1363     QStringList outputlist;
    1364     QString fileprefix = gContext->GetFilePrefix();
     1293    QStringList outputlist(QString::number(destination.size()));
    13651294    QMap<QString, QString> backendIpMap;
    13661295    QMap<QString, QString> backendPortMap;
     1296    QString ip   = gContext->GetSetting("BackendServerIP");
     1297    QString port = gContext->GetSetting("BackendServerPort");
    13671298
    1368     query.prepare(thequery);
    1369 
    1370     if (!query.exec() || !query.isActive())
     1299    ProgramList::iterator it = destination.begin();
     1300    for (it = destination.begin(); it != destination.end(); ++it)
    13711301    {
    1372         MythDB::DBError("MainServer::HandleQueryRecordings", query);
    1373         outputlist << "0";
    1374     }
    1375     else
    1376     {
    1377         outputlist << QString::number(query.size());
     1302        ProgramInfo *proginfo = *it;
     1303        PlaybackSock *slave = NULL;
    13781304
    1379         while (query.next())
    1380         {
    1381             ProgramInfo *proginfo = new ProgramInfo;
     1305        if (proginfo->hostname != gContext->GetHostName())
     1306            slave = getSlaveByHostname(proginfo->hostname);
    13821307
    1383             proginfo->chanid = query.value(0).toString();
    1384             proginfo->startts = query.value(29).toDateTime();
    1385             proginfo->endts = query.value(30).toDateTime();
    1386             proginfo->recstartts = query.value(1).toDateTime();
    1387             proginfo->recendts = query.value(2).toDateTime();
    1388             proginfo->title = query.value(3).toString();
    1389             proginfo->subtitle = query.value(4).toString();
    1390             proginfo->description = query.value(5).toString();
    1391             proginfo->hostname = query.value(6).toString();
    1392 
    1393             proginfo->dupin = RecordingDupInType(query.value(17).toInt());
    1394             proginfo->dupmethod = RecordingDupMethodType(query.value(18).toInt());
    1395             proginfo->recordid = query.value(19).toInt();
    1396             proginfo->chanOutputFilters = query.value(20).toString();
    1397             proginfo->seriesid = query.value(21).toString();
    1398             proginfo->programid = query.value(22).toString();
    1399             proginfo->filesize = stringToLongLong(query.value(23).toString());
    1400             proginfo->lastmodified =
    1401                       QDateTime::fromString(query.value(24).toString(),
    1402                                             Qt::ISODate);
    1403             proginfo->findid = query.value(25).toInt();
    1404 
    1405             if (query.value(26).isNull() ||
    1406                 query.value(26).toString().isEmpty())
     1308        if ((proginfo->hostname == gContext->GetHostName()) ||
     1309            (!slave && masterBackendOverride))
     1310        {
     1311            proginfo->pathname = QString("myth://") + ip + ":" + port
     1312                + "/" + proginfo->pathname;
     1313            if (proginfo->filesize == 0)
    14071314            {
    1408                 proginfo->originalAirDate = QDate (0, 1, 1);
    1409                 proginfo->hasAirDate      = false;
    1410             }
    1411             else
    1412             {
    1413                 proginfo->originalAirDate =
    1414                     QDate::fromString(query.value(26).toString(),Qt::ISODate);
    1415 
    1416                 if (proginfo->originalAirDate > QDate(1940, 1, 1))
    1417                     proginfo->hasAirDate  = true;
    1418                 else
    1419                     proginfo->hasAirDate  = false;
    1420             }
    1421 
    1422             proginfo->pathname = query.value(28).toString();
    1423 
    1424             if (proginfo->hostname.isEmpty())
    1425                 proginfo->hostname = gContext->GetHostName();
    1426 
    1427             if (!query.value(7).toString().isEmpty())
    1428             {
    1429                 proginfo->chanstr = query.value(7).toString();
    1430                 proginfo->channame = query.value(8).toString();
    1431                 proginfo->chansign = query.value(9).toString();
    1432             }
    1433             else
    1434             {
    1435                 proginfo->chanstr = "#" + proginfo->chanid;
    1436                 proginfo->channame = "#" + proginfo->chanid;
    1437                 proginfo->chansign = "#" + proginfo->chanid;
    1438             }
    1439 
    1440             // Taken out of programinfo.cpp just to reduce the number of queries
    1441             int flags = 0;
    1442             flags |= (query.value(10).toInt() == 1) ? FL_COMMFLAG : 0;
    1443             flags |= (query.value(11).toInt() == 1) ? FL_CUTLIST : 0;
    1444             flags |= query.value(12).toInt() ? FL_AUTOEXP : 0;
    1445             flags |= (query.value(14).toInt() == 1) ? FL_BOOKMARK : 0;
    1446             flags |= (query.value(35).toInt() == TRANSCODING_COMPLETE) ?
    1447                       FL_TRANSCODED : 0;
    1448             flags |= (query.value(37).toInt() == 1) ? FL_WATCHED : 0;
    1449             flags |= (query.value(38).toInt() == 1) ? FL_PRESERVED : 0;
    1450 
    1451             inUseKey = query.value(0).toString() + " " +
    1452                        query.value(1).toDateTime().toString(Qt::ISODate);
    1453             if (inUseMap.contains(inUseKey))
    1454                 flags |= inUseMap[inUseKey];
    1455 
    1456             if (query.value(13).toInt())
    1457             {
    1458                 flags |= FL_EDITING;
    1459             }
    1460             else if (query.value(10).toInt() == COMM_FLAG_PROCESSING)
    1461             {
    1462                 if (JobQueue::IsJobRunning(JOB_COMMFLAG, proginfo))
    1463                     flags |= FL_EDITING;
    1464                 else
    1465                     proginfo->SetCommFlagged(COMM_FLAG_NOT_FLAGGED);
    1466             }
    1467 
    1468             proginfo->audioproperties = query.value(32).toInt();
    1469             proginfo->videoproperties = query.value(33).toInt();
    1470             proginfo->subtitleType = query.value(34).toInt();
    1471 
    1472             proginfo->programflags = flags;
    1473 
    1474             proginfo->category = query.value(15).toString();
    1475 
    1476             proginfo->recgroup = query.value(16).toString();
    1477             proginfo->playgroup = query.value(27).toString();
    1478             proginfo->storagegroup =
    1479                 query.value(39).toString();
    1480 
    1481             proginfo->recpriority = query.value(36).toInt();
    1482             proginfo->year = query.value(40).toString();
    1483 
    1484             proginfo->recstatus = rsRecorded;
    1485             if (proginfo->recendts > rectime)
    1486             {
    1487                 for (ri = schedList.begin(); ri != schedList.end(); ri++)
     1315                QString tmpURL = GetPlaybackURL(proginfo);
     1316                QFile checkFile(tmpURL);
     1317                if (!tmpURL.isEmpty() && checkFile.exists())
    14881318                {
    1489                     if ((*ri) && (*ri)->recstatus == rsRecording &&
    1490                         proginfo->chanid == (*ri)->chanid &&
    1491                         proginfo->recstartts == (*ri)->recstartts)
    1492                     {
    1493                         proginfo->recstatus = rsRecording;
    1494                         break;
    1495                     }
     1319                    proginfo->filesize = checkFile.size();
     1320                    if (proginfo->recendts < QDateTime::currentDateTime())
     1321                        proginfo->SetFilesize(proginfo->filesize);
    14961322                }
    14971323            }
    1498 
    1499             proginfo->stars = query.value(31).toDouble();
    1500 
    1501             PlaybackSock *slave = NULL;
    1502 
    1503             if (proginfo->hostname != gContext->GetHostName())
    1504                 slave = getSlaveByHostname(proginfo->hostname);
    1505 
    1506             if ((proginfo->hostname == gContext->GetHostName()) ||
    1507                 (!slave && masterBackendOverride))
     1324        }
     1325        else if (!slave)
     1326        {
     1327            proginfo->pathname = GetPlaybackURL(proginfo);
     1328            if (proginfo->pathname.isEmpty())
    15081329            {
    1509                 proginfo->pathname = QString("myth://") + ip + ":" + port
    1510                                      + "/" + proginfo->pathname;
    1511                 if (proginfo->filesize == 0)
    1512                 {
    1513                     QString tmpURL = GetPlaybackURL(proginfo);
    1514                     QFile checkFile(tmpURL);
    1515                     if (!tmpURL.isEmpty() && checkFile.exists())
    1516                     {
    1517                         proginfo->filesize = checkFile.size();
    1518                         if (proginfo->recendts < QDateTime::currentDateTime())
    1519                             proginfo->SetFilesize(proginfo->filesize);
    1520                     }
    1521                 }
     1330                VERBOSE(VB_IMPORTANT,
     1331                        "MainServer::HandleQueryRecordings()"
     1332                        "\n\t\t\tCouldn't find backend for: " +
     1333                        QString("\n\t\t\t%1 : \"%2\"")
     1334                        .arg(proginfo->title).arg(proginfo->subtitle));
     1335
     1336                proginfo->filesize = 0;
     1337                proginfo->pathname = "file not found";
    15221338            }
    1523             else if (!slave)
     1339        }
     1340        else
     1341        {
     1342            if (proginfo->filesize == 0)
    15241343            {
    1525                 proginfo->pathname = GetPlaybackURL(proginfo);
    1526                 if (proginfo->pathname.isEmpty())
     1344                if (!slave->FillProgramInfo(proginfo, playbackhost))
    15271345                {
    15281346                    VERBOSE(VB_IMPORTANT,
    15291347                            "MainServer::HandleQueryRecordings()"
    1530                             "\n\t\t\tCouldn't find backend for: " +
    1531                             QString("\n\t\t\t%1 : \"%2\"")
    1532                             .arg(proginfo->title).arg(proginfo->subtitle));
    1533 
    1534                     proginfo->filesize = 0;
    1535                     proginfo->pathname = "file not found";
     1348                            "\n\t\t\tCould not fill program info "
     1349                            "from backend");
    15361350                }
    1537             }
    1538             else
    1539             {
    1540                 if (proginfo->filesize == 0)
    1541                 {
    1542                     if (!slave->FillProgramInfo(proginfo, playbackhost))
    1543                     {
    1544                         VERBOSE(VB_IMPORTANT,
    1545                                 "MainServer::HandleQueryRecordings()"
    1546                                 "\n\t\t\tCould not fill program info "
    1547                                 "from backend");
    1548                     }
    1549                     else
    1550                     {
    1551                         if (proginfo->recendts < QDateTime::currentDateTime())
    1552                             proginfo->SetFilesize(proginfo->filesize);
    1553                     }
    1554                 }
    15551351                else
    15561352                {
    1557                     ProgramInfo *p = proginfo;
    1558                     if (!backendIpMap.contains(p->hostname))
    1559                         backendIpMap[p->hostname] =
    1560                             gContext->GetSettingOnHost("BackendServerIp",
    1561                                                        p->hostname);
    1562                     if (!backendPortMap.contains(p->hostname))
    1563                         backendPortMap[p->hostname] =
    1564                             gContext->GetSettingOnHost("BackendServerPort",
    1565                                                        p->hostname);
    1566                     p->pathname = QString("myth://") +
    1567                                   backendIpMap[p->hostname] + ":" +
    1568                                   backendPortMap[p->hostname] + "/" +
    1569                                   p->pathname;
     1353                    if (proginfo->recendts < QDateTime::currentDateTime())
     1354                        proginfo->SetFilesize(proginfo->filesize);
    15701355                }
    15711356            }
     1357            else
     1358            {
     1359                ProgramInfo *p = proginfo;
     1360                if (!backendIpMap.contains(p->hostname))
     1361                    backendIpMap[p->hostname] =
     1362                        gContext->GetSettingOnHost("BackendServerIp",
     1363                                                   p->hostname);
     1364                if (!backendPortMap.contains(p->hostname))
     1365                    backendPortMap[p->hostname] =
     1366                        gContext->GetSettingOnHost("BackendServerPort",
     1367                                                   p->hostname);
     1368                p->pathname = QString("myth://") +
     1369                    backendIpMap[p->hostname] + ":" +
     1370                    backendPortMap[p->hostname] + "/" +
     1371                    p->pathname;
     1372            }
     1373        }
    15721374
    1573             if (slave)
    1574                 slave->DownRef();
     1375        if (slave)
     1376            slave->DownRef();
    15751377
    1576             proginfo->ToStringList(outputlist);
    1577 
    1578             delete proginfo;
    1579         }
     1378        proginfo->ToStringList(outputlist);
    15801379    }
    15811380
    1582     for (ri = schedList.begin(); ri != schedList.end(); ri++)
    1583         delete (*ri);
    1584 
    15851381    SendResponse(pbssock, outputlist);
    15861382}
    15871383
  • programs/mythbackend/scheduler.cpp

     
    439439void Scheduler::FillRecordListFromMaster(void)
    440440{
    441441    RecordingList schedList(false);
    442     schedList.FromScheduler();
     442    bool dummy;
     443    LoadFromScheduler(schedList, dummy);
    443444
    444445    QMutexLocker lockit(reclist_lock);
    445446
  • programs/mythwelcome/welcomedialog.h

     
    66
    77// myth
    88#include "tvremoteutil.h"
    9 #include "programinfo.h"
     9#include "programdetail.h"
    1010#include "mythscreentype.h"
    1111#include "mythuibutton.h"
    1212#include "mythuitext.h"
  • programs/mythwelcome/welcomedialog.cpp

     
    1616#include "mythdbcon.h"
    1717#include "lcddevice.h"
    1818#include "tv.h"
    19 #include "programlist.h"
    2019#include "uitypes.h"
    2120#include "compat.h"
    2221#include "mythdirs.h"
     
    520519        return false;
    521520    }
    522521
    523     ProgramList::GetProgramDetailList(
     522    GetProgramDetailList(
    524523        m_nextRecordingStart, &m_hasConflicts, &m_scheduledList);
    525524
    526525    updateStatus();
  • programs/mythshutdown/main.cpp

     
    1313#include "mythsystem.h"
    1414#include "mythverbose.h"
    1515#include "mythversion.h"
    16 #include "programinfo.h"
    17 #include "programlist.h"
     16#include "programdetail.h"
    1817#include "jobqueue.h"
    1918#include "tv.h"
    2019#include "remoteutil.h"
     
    412411    }
    413412
    414413    QDateTime nextRecordingStart;
    415     ProgramList::GetProgramDetailList(nextRecordingStart);
     414    GetProgramDetailList(nextRecordingStart);
    416415
    417416    // set the wakeup time for the next scheduled recording
    418417    if (!nextRecordingStart.isNull())