Ticket #7691: 7691-v4.patch

File 7691-v4.patch, 35.3 KB (added by danielk, 11 years ago)

This theoretically fixes the flag issue, but is untested.

  • libs/libmythtv/jobqueue.cpp

     
    20122012                               .arg(comment)).toLocal8Bit();
    20132013                }
    20142014
    2015                 MythEvent me("RECORDING_LIST_CHANGE");
    2016                 gContext->dispatch(me);
    2017 
    20182015                program_info->SetTranscoded(TRANSCODING_COMPLETE);
    20192016            }
    20202017            else
     
    21652162        comment = tr("%n commercial break(s)", "", breaksFound);
    21662163        ChangeJobStatus(jobID, JOB_FINISHED, comment);
    21672164
    2168         MythEvent me("RECORDING_LIST_CHANGE");
    2169         gContext->dispatch(me);
     2165        program_info->SendUpdateEvent();
    21702166
    21712167        program_info->pathname = program_info->GetPlaybackURL();
    21722168        (new PreviewGenerator(program_info, PreviewGenerator::kLocal))->Run();
     
    22842280
    22852281        ChangeJobStatus(jobID, JOB_FINISHED, "Successfully Completed.");
    22862282
    2287         MythEvent me("RECORDING_LIST_CHANGE");
    2288         gContext->dispatch(me);
     2283        if (pginfo)
     2284            pginfo->SendUpdateEvent();
    22892285    }
    22902286
    22912287    RemoveRunningJob(jobID);
  • libs/libmythtv/tv_rec.cpp

     
    504504        curRecording->recordid = rcinfo->recordid;
    505505        curRecording->recendts = rcinfo->recendts;
    506506        curRecording->UpdateRecordingEnd();
    507         MythEvent me("RECORDING_LIST_CHANGE");
    508         gContext->dispatch(me);
    509507
    510508        recordEndTime = curRecording->recendts.addSecs(post_roll_seconds);
    511509
     
    785783}
    786784
    787785/** \fn TVRec::StartedRecording(RecordingInfo *curRec)
    788  *  \brief Inserts a "curRec" into the database, and issues a
    789  *         "RECORDING_LIST_CHANGE" event.
     786 *  \brief Inserts a "curRec" into the database
    790787 *  \param curRec Recording to add to database.
    791788 *  \sa ProgramInfo::StartedRecording(const QString&)
    792789 */
     
    801798
    802799    if (curRec->chancommfree != 0)
    803800        curRec->SetCommFlagged(COMM_FLAG_COMMFREE);
    804 
    805     MythEvent me("RECORDING_LIST_CHANGE");
    806     gContext->dispatch(me);
    807801}
    808802
    809803/** \fn TVRec::FinishedRecording(RecordingInfo *curRec)
     
    10691063 *
    10701064 *   If killfile is true, the recording is deleted.
    10711065 *
    1072  *   A "RECORDING_LIST_CHANGE" message is dispatched.
    1073  *
    10741066 *   Finally, if there was a recording and it was not deleted,
    10751067 *   schedule any post-processing jobs.
    10761068 *
     
    11401132        curRecording = NULL;
    11411133    }
    11421134
    1143     MythEvent me("RECORDING_LIST_CHANGE");
    1144     gContext->dispatch(me);
    11451135    pauseNotify = true;
    11461136
    11471137    if (GetDTVChannel())
  • libs/libmythtv/recordinginfo.cpp

     
    223223        MythDB::DBError("RecGroup update", query);
    224224
    225225    recgroup = newrecgroup;
     226
     227    SendUpdateEvent();
    226228}
    227229
    228230/** \fn RecordingInfo::ApplyRecordPlayGroupChange(const QString &newplaygroup)
     
    246248        MythDB::DBError("PlayGroup update", query);
    247249
    248250    playgroup = newplaygroup;
     251
     252    SendUpdateEvent();
    249253}
    250254
    251255/** \fn RecordingInfo::ApplyStorageGroupChange(const QString &newstoragegroup)
     
    269273        MythDB::DBError("StorageGroup update", query);
    270274
    271275    storagegroup = newstoragegroup;
     276
     277    SendUpdateEvent();
    272278}
    273279
    274280/** \fn RecordingInfo::ApplyRecordRecTitleChange(const QString &newTitle, const QString &newSubtitle)
     
    295301
    296302    title = newTitle;
    297303    subtitle = newSubtitle;
     304
     305    SendUpdateEvent();
    298306}
    299307
    300308/** \brief Sets the transcoder profile for a recording
     
    546554    query.bindValue(":START", startts);
    547555    if (!query.exec() || !query.isActive())
    548556        MythDB::DBError("Copy program ratings on record", query);
     557
     558    SendAddedEvent();
    549559}
    550560
    551561static bool insert_program(const RecordingInfo        *pg,
     
    705715        VERBOSE(VB_GENERAL, QString("%1 %2").arg(msg).arg(details));
    706716        gContext->LogEntry("scheduler", LP_NOTICE, msg, details);
    707717    }
     718
     719    SendUpdateEvent();
    708720}
    709721
    710722/** \fn RecordingInfo::UpdateRecordingEnd(void)
     
    724736
    725737    if (!query.exec())
    726738        MythDB::DBError("UpdateRecordingEnd update", query);
     739
     740    SendUpdateEvent();
    727741}
    728742
    729743/** \fn RecordingInfo::ReactivateRecording(void)
  • libs/libmyth/programinfo.h

     
    107107    FL_BOOKMARK       = 0x0010,
    108108    FL_INUSERECORDING = 0x0020,
    109109    FL_INUSEPLAYING   = 0x0040,
     110    FL_REALLYEDITING  = 0x0080,
     111    FL_COMMPROCESSING = 0x0100,
     112    FL_DELETEPENDING  = 0x0200,
    110113    FL_TRANSCODED     = 0x0400,
    111114    FL_WATCHED        = 0x0800,
    112115    FL_PRESERVED      = 0x1000,
     
    319322
    320323    // Slow DB sets
    321324    void SetFilesize(long long fsize);
    322     void SetBookmark(long long pos) const;
     325    void SetBookmark(long long pos);
    323326    void SetDVDBookmark(QStringList fields) const;
    324     void SetEditing(bool edit) const;
    325     void SetTranscoded(int transFlag) const;
    326     void SetWatchedFlag(bool watchedFlag) const;
    327     void SetDeleteFlag(bool deleteFlag) const;
    328     void SetCommFlagged(int flag) const; // 1 = flagged, 2 = processing
    329     void SetAutoExpire(int autoExpire, bool updateDelete = false) const;
    330     void SetPreserveEpisode(bool preserveEpisode) const;
     327    void SetEditing(bool edit);
     328    void SetTranscoded(int transFlag);
     329    void SetWatchedFlag(bool watchedFlag);
     330    void SetDeleteFlag(bool deleteFlag);
     331    void SetCommFlagged(int flag); // 1 = flagged, 2 = processing
     332    void SetAutoExpire(int autoExpire, bool updateDelete = false);
     333    void SetPreserveEpisode(bool preserveEpisode);
    331334    bool SetRecordBasename(const QString &basename);
    332335    void UpdateLastDelete(bool setTime) const;
    333336
     
    376379    // Translations for play,recording, & storage groups +
    377380    static QString i18n(const QString&);
    378381
     382    /// Sends event out that the ProgramInfo should be reloaded.
     383    void SendUpdateEvent(void) const;
     384    /// Sends event out that the ProgramInfo should be added to lists.
     385    void SendAddedEvent(void) const;
     386    /// Sends event out that the ProgramInfo should be delete from lists.
     387    void SendDeletedEvent(void) const;
     388
    379389  protected:
    380390    // Creates a basename from the start and end times
    381391    QString CreateRecordBasename(const QString &ext) const;
    382     /// Sends event out that the ProgramInfo should be reloaded.
    383     void Update(void) const;
    384392
    385393  public:
    386394    // data
  • libs/libmyth/programinfo.cpp

     
    4141QMutex ProgramInfo::staticDataLock;
    4242QString ProgramInfo::unknownTitle;
    4343
     44static void set_flag(int &flags, int flag_to_set, bool is_set)
     45{
     46    flags &= ~flag_to_set;
     47    if (is_set)
     48        flags |= flag_to_set;
     49}
     50
    4451/** \fn ProgramInfo::ProgramInfo(void)
    4552 *  \brief Null constructor.
    4653 */
     
    15501557        return false;
    15511558    }
    15521559
    1553     Update();
     1560    SendUpdateEvent();
    15541561    return true;
    15551562}
    15561563
     
    16731680    if (!query.exec() || !query.isActive())
    16741681        MythDB::DBError("File size update", query);
    16751682
    1676     Update();
     1683    SendUpdateEvent();
    16771684}
    16781685
    16791686/** \fn ProgramInfo::GetFilesize(void)
     
    17251732    return ret;
    17261733}
    17271734
    1728 /** \fn ProgramInfo::SetBookmark(long long pos) const
     1735/** \fn ProgramInfo::SetBookmark(long long)
    17291736 *  \brief Sets a bookmark position in database.
    17301737 *
    17311738 */
    1732 void ProgramInfo::SetBookmark(long long pos) const
     1739void ProgramInfo::SetBookmark(long long pos)
    17331740{
    17341741    ClearMarkupMap(MARK_BOOKMARK);
    17351742
     
    17511758            "WHERE chanid    = :CHANID AND "
    17521759            "      starttime = :STARTTIME");
    17531760
    1754         query.bindValue(":BOOKMARKFLAG", is_valid ? 1 : 0);
     1761        query.bindValue(":BOOKMARKFLAG", is_valid);
    17551762        query.bindValue(":CHANID",       chanid);
    17561763        query.bindValue(":STARTTIME",    recstartts);
    17571764
     
    17591766            MythDB::DBError("bookmark flag update", query);
    17601767    }
    17611768
    1762     Update();
     1769    set_flag(programflags, FL_BOOKMARK, is_valid);
     1770
     1771    SendUpdateEvent();
    17631772}
    17641773
    1765 void ProgramInfo::Update(void) const
     1774void ProgramInfo::SendUpdateEvent(void) const
    17661775{
    17671776    QStringList list;
    17681777    ToStringList(list);
    1769     MythEvent me(QString("UPDATE_PROG_INFO"), list);
    1770     RemoteSendEvent(me);
     1778    RemoteSendEvent(MythEvent(QString("UPDATE_PROG_INFO"), list));
    17711779}
    17721780
     1781void ProgramInfo::SendAddedEvent(void) const
     1782{
     1783    QStringList list;
     1784    ToStringList(list);
     1785    RemoteSendEvent(MythEvent(QString("RECORDING_LIST_CHANGE ADD"), list));
     1786}
     1787
     1788void ProgramInfo::SendDeletedEvent(void) const
     1789{
     1790    QString msg = QString("RECORDING_LIST_CHANGE DELETE %1 %2")
     1791        .arg(chanid).arg(recstartts.toString(Qt::ISODate));
     1792    RemoteSendEvent(MythEvent(msg));
     1793}
     1794
    17731795/** \brief Queries Latest bookmark timestamp from the database.
    17741796 *  If the timestamp has not been set this returns an invalid QDateTime.
    17751797 */
     
    18971919    if (!query.exec() || !query.isActive())
    18981920        MythDB::DBError("SetDVDBookmark updating", query);
    18991921
    1900     Update();
     1922    SendUpdateEvent();
    19011923}
    1902 /** \fn ProgramInfo::SetWatchedFlag(bool) const
     1924/** \fn ProgramInfo::SetWatchedFlag(bool)
    19031925 *  \brief Set "watched" field in recorded/videometadata to "watchedFlag".
    19041926 *  \param watchedFlag value to set watched field to.
    19051927 */
    1906 void ProgramInfo::SetWatchedFlag(bool watchedFlag) const
     1928void ProgramInfo::SetWatchedFlag(bool watchedFlag)
    19071929{
    1908 
    19091930    if (!isVideo)
    19101931    {
    19111932        MSqlQuery query(MSqlQuery::InitCon());
     
    19161937                    " AND starttime = :STARTTIME ;");
    19171938        query.bindValue(":CHANID", chanid);
    19181939        query.bindValue(":STARTTIME", recstartts);
     1940        query.bindValue(":WATCHEDFLAG", watchedFlag);
    19191941
    1920         if (watchedFlag)
    1921             query.bindValue(":WATCHEDFLAG", 1);
    1922         else
    1923             query.bindValue(":WATCHEDFLAG", 0);
    1924 
    1925         if (!query.exec() || !query.isActive())
     1942        if (!query.exec())
    19261943            MythDB::DBError("Set watched flag", query);
    19271944        else
    19281945            UpdateLastDelete(watchedFlag);
    19291946    }
    19301947    else if (isVideo && !pathname.startsWith("dvd:"))
    19311948    {
     1949        QString url = pathname;
     1950        if (url.startsWith("myth://"))
     1951        {
     1952            url = QUrl(url).path();
     1953            url.remove(0,1);
     1954        }
     1955
    19321956        MSqlQuery query(MSqlQuery::InitCon());
    1933 
    19341957        query.prepare("UPDATE videometadata"
    19351958                    " SET watched = :WATCHEDFLAG"
    19361959                    " WHERE title = :TITLE"
     
    19381961                    " AND filename = :FILENAME ;");
    19391962        query.bindValue(":TITLE", title);
    19401963        query.bindValue(":SUBTITLE", subtitle);
     1964        query.bindValue(":FILENAME", url);
     1965        query.bindValue(":WATCHEDFLAG", watchedFlag);
    19411966
    1942         QString url = pathname;
    1943         if (url.startsWith("myth://"))
    1944         {
    1945             url = QUrl(url).path();
    1946             url.remove(0,1);
    1947             query.bindValue(":FILENAME", url);
    1948         }
    1949         else
    1950             query.bindValue(":FILENAME", url);
    1951 
    1952         if (watchedFlag)
    1953             query.bindValue(":WATCHEDFLAG", 1);
    1954         else
    1955             query.bindValue(":WATCHEDFLAG", 0);
    1956                            
    1957         if (!query.exec() || !query.isActive())
     1967        if (!query.exec())
    19581968            MythDB::DBError("Set watched flag", query);
    19591969    }
    19601970
    1961     Update();
     1971    set_flag(programflags, FL_WATCHED, watchedFlag);
     1972
     1973    SendUpdateEvent();
    19621974}
    19631975
    19641976/** \fn ProgramInfo::IsEditing(void) const
     
    19681980 */
    19691981bool ProgramInfo::IsEditing(void) const
    19701982{
     1983    bool editing = programflags & FL_REALLYEDITING;
     1984
    19711985    MSqlQuery query(MSqlQuery::InitCon());
    19721986
    19731987    query.prepare("SELECT editing FROM recorded"
     
    19771991    query.bindValue(":STARTTIME", recstartts);
    19781992
    19791993    if (query.exec() && query.next())
    1980     {
    1981         return query.value(0).toBool();
    1982     }
     1994        editing = query.value(0).toBool();
    19831995
    1984     return false;
     1996    /*
     1997    set_flag(programflags, FL_REALLYEDITING, editing);
     1998    set_flag(programflags, FL_EDITING, ((programflags & FL_REALLYEDITING) ||
     1999                                        (programflags & COMM_FLAG_PROCESSING)));
     2000    */
     2001    return editing;
    19852002}
    19862003
    1987 /** \fn ProgramInfo::SetEditing(bool) const
     2004/** \fn ProgramInfo::SetEditing(bool)
    19882005 *  \brief Sets "editing" field in "recorded" table to "edit"
    19892006 *  \param edit Editing state to set.
    19902007 */
    1991 void ProgramInfo::SetEditing(bool edit) const
     2008void ProgramInfo::SetEditing(bool edit)
    19922009{
    19932010    MSqlQuery query(MSqlQuery::InitCon());
    19942011
     
    20002017    query.bindValue(":CHANID", chanid);
    20012018    query.bindValue(":STARTTIME", recstartts);
    20022019
    2003     if (!query.exec() || !query.isActive())
     2020    if (!query.exec())
    20042021        MythDB::DBError("Edit status update", query);
    20052022
    2006     Update();
     2023    set_flag(programflags, FL_REALLYEDITING, edit);
     2024    set_flag(programflags, FL_EDITING, ((programflags & FL_REALLYEDITING) ||
     2025                                        (programflags & COMM_FLAG_PROCESSING)));
     2026
     2027    SendUpdateEvent();
    20072028}
    20082029
    2009 /** \fn ProgramInfo::SetDeleteFlag(bool) const
     2030/** \fn ProgramInfo::SetDeleteFlag(bool)
    20102031 *  \brief Set "deletepending" field in "recorded" table to "deleteFlag".
    20112032 *  \param deleteFlag value to set delete pending field to.
    20122033 */
    2013 void ProgramInfo::SetDeleteFlag(bool deleteFlag) const
     2034void ProgramInfo::SetDeleteFlag(bool deleteFlag)
    20142035{
    20152036    MSqlQuery query(MSqlQuery::InitCon());
    20162037
     
    20202041                  " AND starttime = :STARTTIME ;");
    20212042    query.bindValue(":CHANID", chanid);
    20222043    query.bindValue(":STARTTIME", recstartts);
     2044    query.bindValue(":DELETEFLAG", deleteFlag);
    20232045
    2024     if (deleteFlag)
    2025         query.bindValue(":DELETEFLAG", 1);
    2026     else
    2027         query.bindValue(":DELETEFLAG", 0);
    2028 
    2029     if (!query.exec() || !query.isActive())
     2046    if (!query.exec())
    20302047        MythDB::DBError("Set delete flag", query);
    20312048
    2032     Update();
     2049    set_flag(programflags, FL_DELETEPENDING, deleteFlag);
     2050
     2051    if (!deleteFlag)
     2052        SendAddedEvent();
     2053
     2054    SendUpdateEvent();
    20332055}
    20342056
    20352057/** \fn ProgramInfo::IsCommFlagged(void) const
     
    21272149    return false;
    21282150}
    21292151
    2130 /** \fn ProgramInfo::SetTranscoded(int transFlag) const
     2152/** \fn ProgramInfo::SetTranscoded(int)
    21312153 *  \brief Set "transcoded" field in "recorded" table to "transFlag".
    21322154 *  \param transFlag value to set transcoded field to.
    21332155 */
    2134 void ProgramInfo::SetTranscoded(int transFlag) const
     2156void ProgramInfo::SetTranscoded(int transFlag)
    21352157{
    21362158    MSqlQuery query(MSqlQuery::InitCon());
    21372159
     
    21462168    if(!query.exec() || !query.isActive())
    21472169        MythDB::DBError("Transcoded status update", query);
    21482170
    2149     Update();
     2171    set_flag(programflags, FL_TRANSCODED, 1 == transFlag);
     2172
     2173    SendUpdateEvent();
    21502174}
    21512175
    2152 /** \fn ProgramInfo::SetCommFlagged(int) const
     2176/** \fn ProgramInfo::SetCommFlagged(int)
    21532177 *  \brief Set "commflagged" field in "recorded" table to "flag".
    21542178 *  \param flag value to set commercial flagging field to.
    21552179 */
    2156 void ProgramInfo::SetCommFlagged(int flag) const
     2180void ProgramInfo::SetCommFlagged(int flag)
    21572181{
    21582182    MSqlQuery query(MSqlQuery::InitCon());
    21592183
     
    21682192    if (!query.exec() || !query.isActive())
    21692193        MythDB::DBError("Commercial Flagged status update", query);
    21702194
    2171     Update();
     2195    set_flag(programflags, FL_COMMFLAG,       COMM_FLAG_DONE == flag);
     2196    set_flag(programflags, FL_COMMPROCESSING, COMM_FLAG_PROCESSING == flag);
     2197    set_flag(programflags, FL_EDITING, ((programflags & FL_REALLYEDITING) ||
     2198                                        (programflags & COMM_FLAG_PROCESSING)));
     2199    SendUpdateEvent();
    21722200}
    21732201
    2174 /** \fn ProgramInfo::SetPreserveEpisode(bool) const
     2202/** \fn ProgramInfo::SetPreserveEpisode(bool)
    21752203 *  \brief Set "preserve" field in "recorded" table to "preserveEpisode".
    21762204 *  \param preserveEpisode value to set preserve field to.
    21772205 */
    2178 void ProgramInfo::SetPreserveEpisode(bool preserveEpisode) const
     2206void ProgramInfo::SetPreserveEpisode(bool preserveEpisode)
    21792207{
    21802208    MSqlQuery query(MSqlQuery::InitCon());
    21812209
     
    21922220    else
    21932221        UpdateLastDelete(false);
    21942222
    2195     Update();
     2223    set_flag(programflags, FL_PRESERVED, preserveEpisode);
     2224
     2225    SendUpdateEvent();
    21962226}
    21972227
    21982228/**
    21992229 *  \brief Set "autoexpire" field in "recorded" table to "autoExpire".
    22002230 *  \param autoExpire value to set auto expire field to.
    22012231 */
    2202 void ProgramInfo::SetAutoExpire(int autoExpire, bool updateDelete) const
     2232void ProgramInfo::SetAutoExpire(int autoExpire, bool updateDelete)
    22032233{
    22042234    MSqlQuery query(MSqlQuery::InitCon());
    22052235
     
    22162246    else if (updateDelete)
    22172247        UpdateLastDelete(true);
    22182248
    2219     Update();
     2249    set_flag(programflags, FL_AUTOEXP, autoExpire);
     2250
     2251    SendUpdateEvent();
    22202252}
    22212253
    22222254/** \fn ProgramInfo::UpdateLastDelete(bool) const
     
    23442376            MythDB::DBError("cutlist flag update", query);
    23452377    }
    23462378
    2347     Update();
     2379    SendUpdateEvent();
    23482380}
    23492381
    23502382void ProgramInfo::SetCommBreakList(frm_dir_map_t &frames) const
     
    29472979
    29482980    if (width > 1300)
    29492981    {
    2950         VERBOSE(VB_IMPORTANT, QString("Recording designated 1080i/p because width was %1").arg(width));
     2982        VERBOSE(VB_GENERAL, LOC +
     2983                QString("Recording designated 1080i/p because width was %1")
     2984                .arg(width));
    29512985        videoproperties |= VID_1080;
    29522986
    29532987        query.bindValue(":VALUE", "1080");
     
    29592993    }
    29602994    else if (width > 800)
    29612995    {
    2962         VERBOSE(VB_IMPORTANT, QString("Recording designated 720p because width was %1").arg(width));
     2996        VERBOSE(VB_GENERAL, LOC +
     2997                QString("Recording designated 720p because width was %1")
     2998                .arg(width));
    29632999        videoproperties |= VID_720;
    29643000
    29653001        query.bindValue(":VALUE", "720");
     
    29713007    }
    29723008    else
    29733009    {
    2974         VERBOSE(VB_IMPORTANT, QString("Unknown type, recording width was %1").arg(width));
     3010        VERBOSE(VB_IMPORTANT, LOC_ERR +
     3011                QString("Unknown type, recording width was %1").arg(width));
    29753012        return;
    29763013    }
    29773014
    29783015    m_videoWidth = width;
     3016
     3017    SendUpdateEvent();
    29793018}
    29803019
    29813020/** \fn ProgramInfo::RecTypeChar(void) const
     
    33823421    int flags = 0;
    33833422    MSqlQuery query(MSqlQuery::InitCon());
    33843423
    3385     query.prepare("SELECT commflagged, cutlist, autoexpire, "
    3386                   "editing, bookmark, watched, preserve, transcoded "
    3387                   "FROM recorded LEFT JOIN recordedprogram ON "
    3388                   "(recorded.chanid = recordedprogram.chanid AND "
    3389                   "recorded.progstart = recordedprogram.starttime) "
    3390                   "WHERE recorded.chanid = :CHANID AND recorded.starttime = :STARTTIME ;");
     3424    query.prepare(
     3425        "SELECT commflagged, cutlist,    autoexpire, "
     3426        "       editing,     bookmark,   watched,    "
     3427        "       preserve,    transcoded, deletepending "
     3428        "FROM recorded LEFT JOIN recordedprogram "
     3429        "ON (recorded.chanid    = recordedprogram.chanid AND "
     3430        "    recorded.progstart = recordedprogram.starttime) "
     3431        "WHERE recorded.chanid    = :CHANID AND "
     3432        "      recorded.starttime = :STARTTIME");
    33913433    query.bindValue(":CHANID", chanid);
    33923434    query.bindValue(":STARTTIME", recstartts);
    33933435
    33943436    if (query.exec() && query.next())
    33953437    {
    33963438        flags |= (query.value(0).toInt() == COMM_FLAG_DONE) ? FL_COMMFLAG : 0;
    3397         flags |= (query.value(1).toInt() == 1) ? FL_CUTLIST : 0;
    3398         flags |= query.value(2).toInt() ? FL_AUTOEXP : 0;
    3399         if ((query.value(3).toInt()) ||
    3400             (query.value(0).toInt() == COMM_FLAG_PROCESSING))
    3401             flags |= FL_EDITING;
    3402         flags |= (query.value(4).toInt() == 1) ? FL_BOOKMARK : 0;
    3403         flags |= (query.value(5).toInt() == 1) ? FL_WATCHED : 0;
    3404         flags |= (query.value(6).toInt() == 1) ? FL_PRESERVED : 0;
    3405         flags |= (query.value(7).toInt() == 1) ? FL_TRANSCODED : 0;
     3439        flags |= (query.value(0).toInt() == COMM_FLAG_PROCESSING) ?
     3440            FL_COMMPROCESSING : 0;
     3441        flags |= (query.value(7).toInt() == 1) ? FL_TRANSCODED    : 0;
     3442
     3443        flags |= query.value(1).toInt() ? FL_CUTLIST       : 0;
     3444        flags |= query.value(2).toInt() ? FL_AUTOEXP       : 0;
     3445        flags |= query.value(3).toInt() ? FL_REALLYEDITING : 0;
     3446        flags |= query.value(4).toInt() ? FL_BOOKMARK      : 0;
     3447        flags |= query.value(5).toInt() ? FL_WATCHED       : 0;
     3448        flags |= query.value(6).toInt() ? FL_PRESERVED     : 0;
     3449        flags |= query.value(8).toInt() ? FL_DELETEPENDING : 0;
     3450
     3451        flags |= ((flags & FL_REALLYEDITING) ||
     3452                  (flags & COMM_FLAG_PROCESSING)) ? FL_EDITING : 0;
    34063453    }
    34073454
    34083455    return flags;
     
    34893536        recgroup = query.value(0).toString();
    34903537    }
    34913538
    3492     Update();
     3539    SendUpdateEvent();
    34933540}
    34943541
    34953542void ProgramInfo::MarkAsInUse(bool inuse, QString usedFor)
     
    35283575
    35293576    if (!inuse)
    35303577    {
    3531         if (!gContext->IsBackend())
    3532             RemoteSendMessage("RECORDING_LIST_CHANGE");
    35333578        inUseForWhat.clear();
     3579        SendUpdateEvent();
    35343580        return;
    35353581    }
    35363582
     
    35933639    query.bindValue(":RECHOST", hostname);
    35943640    query.bindValue(":RECDIR", recDir);
    35953641
    3596     if (!query.exec() || !query.isActive())
     3642    if (!query.exec())
    35973643        MythDB::DBError("SetInUse", query);
    35983644
    35993645    // Let others know we changed status
    3600     if (notifyOfChange && !gContext->IsBackend())
    3601         RemoteSendMessage("RECORDING_LIST_CHANGE");
     3646    if (notifyOfChange)
     3647        SendUpdateEvent();
    36023648}
    36033649
    36043650/** \fn ProgramInfo::GetChannel(QString&,QString&) const
  • programs/mythfrontend/playbackbox.cpp

     
    11371137    }
    11381138
    11391139    m_connected = FillList(m_fillListFromCache);
     1140    m_fillListFromCache = true;
    11401141}
    11411142
    11421143bool PlaybackBox::FillList(bool useCachedData)
     
    36613662        if (message.left(21) == "RECORDING_LIST_CHANGE")
    36623663        {
    36633664            QStringList tokens = message.simplified().split(" ");
    3664             if (tokens.size() == 1)
     3665            if ((tokens.size() == 4) && (tokens[1] == "ADD"))
    36653666            {
    3666                 m_fillListFromCache = false;
    3667                 if (!m_fillListTimer->isActive())
    3668                 {
    3669                     m_fillListTimer->stop();
    3670                     m_fillListTimer->setSingleShot(true);
    3671                     m_fillListTimer->start(1000);
    3672                 }
     3667                ProgramInfo evinfo;
     3668                if (evinfo.FromStringList(me->ExtraDataList(), 0))
     3669                    HandleRecordingAddEvent(evinfo);
    36733670            }
    3674             else if ((tokens[1] == "DELETE") && (tokens.size() == 4))
     3671            if ((tokens.size() == 4) && (tokens[1] == "DELETE"))
    36753672            {
    3676                 m_freeSpaceNeedsUpdate = true;
    3677                 m_progCacheLock.lock();
    3678                 if (!m_progCache)
    3679                 {
    3680                     m_progCacheLock.unlock();
    3681                     m_freeSpaceNeedsUpdate = true;
    3682                     m_fillListFromCache = false;
    3683                     m_fillListTimer->stop();
    3684                     m_fillListTimer->setSingleShot(true);
    3685                     m_fillListTimer->start(1000);
    3686                     return;
    3687                 }
    3688                 vector<ProgramInfo *>::iterator i = m_progCache->begin();
    3689                 for ( ; i != m_progCache->end(); ++i)
    3690                 {
    3691                    if (((*i)->chanid == tokens[2]) &&
    3692                        ((*i)->recstartts.toString(Qt::ISODate) == tokens[3]))
    3693                    {
    3694                         // We've set this recording to be deleted locally
    3695                         // it's no longer in the recording list, so don't
    3696                         // trigger a list reload which would cause a UI lag
    3697                         if ((*i)->availableStatus != asPendingDelete
    3698                              || m_currentGroup == m_watchGroupLabel)
    3699                         {
    3700                             m_recordingList->RemoveItem(
    3701                                             m_recordingList->GetItemByData(
    3702                                                         qVariantFromValue(*i)));
    3703                             if (m_recordingList->GetCount() == 0)
    3704                                 m_groupList->RemoveItem(
    3705                                             m_groupList->GetItemCurrent());
    3706                         }
    3707                         (*i)->availableStatus = asDeleted;
    3708                         m_progCacheLock.unlock();
    3709                         return;
    3710                    }
    3711                 }
    3712 
    3713                 m_progCacheLock.unlock();
    3714                 if (!m_fillListTimer->isActive())
    3715                 {
    3716                     m_fillListFromCache = true;
    3717                     m_fillListTimer->stop();
    3718                     m_fillListTimer->setSingleShot(true);
    3719                     m_fillListTimer->start(1000);
    3720                 }
     3673                uint chanid = tokens[2].toUInt();
     3674                QDateTime recstartts = QDateTime::fromString(tokens[3]);
     3675                if (chanid && recstartts.isValid())
     3676                    HandleRecordingRemoveEvent(chanid, recstartts);
    37213677            }
     3678            else
     3679            {
     3680                m_fillListFromCache = false;
     3681                ScheduleFillList();
     3682            }
    37223683        }
    37233684        else if (message.left(15) == "NETWORK_CONTROL")
    37243685        {
     
    37583719        {
    37593720            ProgramInfo evinfo;
    37603721            if (evinfo.FromStringList(me->ExtraDataList(), 0))
    3761             {
    3762                 UpdateProgramInfo(evinfo);
     3722                HandleUpdateProgramInfoEvent(evinfo);
     3723        }
     3724    }
     3725    else
     3726        ScheduleCommon::customEvent(event);
     3727}
    37633728
    3764                 ProgramInfo *dst = findMatchingProg(&evinfo);
    3765                 MythUIButtonListItem *item = NULL;
    3766                 if (dst)
    3767                 {
    3768                     item = m_recordingList->GetItemByData(
    3769                         qVariantFromValue(dst));
    3770                 }
     3729void PlaybackBox::HandleRecordingRemoveEvent(
     3730    uint chanid, const QDateTime &recstartts)
     3731{
     3732    bool found = false;
    37713733
    3772                 if (item)
    3773                 {
    3774                     MythUIButtonListItem *sel_item =
    3775                         m_recordingList->GetItemCurrent();
    3776                     UpdateProgramInfo(item, item == sel_item, true);
    3777                 }
    3778                 else
    3779                 {
    3780                     VERBOSE(VB_IMPORTANT,
    3781                             "Got UPDATE_PROG_INFO, but the program "
    3782                             "is unknown to us.");
    3783                 }
     3734    m_freeSpaceNeedsUpdate = true;
     3735
     3736    m_progCacheLock.lock();
     3737    if (m_progCache)
     3738    {
     3739        vector<ProgramInfo *>::iterator it = m_progCache->begin();
     3740        for ( ; it != m_progCache->end(); ++it)
     3741        {
     3742            if ((chanid     == (*it)->chanid.toUInt()) &&
     3743                (recstartts == (*it)->recstartts))
     3744            {
     3745                found = true;
     3746                break;
    37843747            }
    3785             else
     3748        }
     3749
     3750        if (it != m_progCache->end())
     3751        {
     3752            if (((*it)->availableStatus != asPendingDelete) ||
     3753                (m_currentGroup == m_watchGroupLabel))
    37863754            {
    3787                 VERBOSE(VB_IMPORTANT, "Failed to parse UPDATE_PROG_INFO");
     3755                m_recordingList->RemoveItem(
     3756                    m_recordingList->GetItemByData(
     3757                        qVariantFromValue(*it)));
     3758                if (m_recordingList->GetCount() == 0)
     3759                    m_groupList->RemoveItem(
     3760                        m_groupList->GetItemCurrent());
    37883761            }
     3762            (*it)->availableStatus = asDeleted;
    37893763        }
    37903764    }
    37913765    else
    3792         ScheduleCommon::customEvent(event);
     3766    {
     3767        m_fillListFromCache = false;
     3768    }
     3769    m_progCacheLock.unlock();
     3770
     3771    if (!found)
     3772        ScheduleFillList();
    37933773}
    37943774
     3775void PlaybackBox::HandleRecordingAddEvent(const ProgramInfo &evinfo)
     3776{
     3777    m_progCacheLock.lock();
     3778    if (m_progCache)
     3779    {
     3780        vector<ProgramInfo *>::iterator it = m_progCache->begin();
     3781        for ( ; it != m_progCache->end(); ++it)
     3782        {
     3783            if ((evinfo.chanid     == (*it)->chanid) &&
     3784                (evinfo.recstartts == (*it)->recstartts))
     3785            {
     3786                **it = evinfo;
     3787                break;
     3788            }
     3789        }
     3790
     3791        if (it == m_progCache->end())
     3792            m_progCache->push_back(new ProgramInfo(evinfo));
     3793    }
     3794    m_progCacheLock.unlock();
     3795
     3796    ScheduleFillList();
     3797}
     3798
     3799void PlaybackBox::HandleUpdateProgramInfoEvent(const ProgramInfo &evinfo)
     3800{
     3801    ProgramInfo *dst = findMatchingProg(&evinfo);
     3802    QString old_recgroup;
     3803    if (dst)
     3804        old_recgroup = dst->recgroup;
     3805
     3806    UpdateProgramInfo(evinfo);
     3807
     3808    // If the program is not in the the recording lists, then it
     3809    // is either a program that was just removed from the "LiveTV"
     3810    // recording list and should possibly be displayed now, or it
     3811    // is still in the "LiveTV" recording group and we're not
     3812    // displaying programs in that group. Handle appropriately..
     3813    if (!dst)
     3814    {
     3815        if (evinfo.recgroup != "LiveTV")
     3816            ScheduleFillList();
     3817        return;
     3818    }
     3819
     3820    // If the recording group has changed, reload lists from the
     3821    // recently updated cache..
     3822    if (dst->recgroup != old_recgroup)
     3823    {
     3824        ScheduleFillList();
     3825        return;
     3826    }
     3827
     3828    MythUIButtonListItem *item =
     3829        m_recordingList->GetItemByData(qVariantFromValue(dst));
     3830
     3831    if (item)
     3832    {
     3833        MythUIButtonListItem *sel_item =
     3834            m_recordingList->GetItemCurrent();
     3835        UpdateProgramInfo(item, item == sel_item, true);
     3836    }
     3837    else
     3838    {
     3839        VERBOSE(VB_GENERAL, LOC +
     3840                QString("Got UPDATE_PROG_INFO event about a title unknown "
     3841                        "to us only in m_recordingList\n %1:%2")
     3842                .arg(evinfo.title).arg(evinfo.subtitle));
     3843    }
     3844}
     3845
     3846void PlaybackBox::ScheduleFillList(void)
     3847{
     3848    if (!m_fillListTimer->isActive())
     3849    {
     3850        m_fillListTimer->stop();
     3851        m_fillListTimer->setSingleShot(true);
     3852        m_fillListTimer->start(1000);
     3853    }
     3854}
     3855
    37953856bool PlaybackBox::fileExists(ProgramInfo *pginfo)
    37963857{
    37973858    if (pginfo)
  • programs/mythfrontend/playbackbox.h

     
    327327    void clearProgramCache(void);
    328328
    329329    void HandlePreviewEvent(const ProgramInfo &evinfo);
     330    void HandleRecordingRemoveEvent(uint chanid, const QDateTime &recstartts);
     331    void HandleRecordingAddEvent(const ProgramInfo &evinfo);
     332    void HandleUpdateProgramInfoEvent(const ProgramInfo &evinfo);
     333    void ScheduleFillList(void);
    330334
    331335    void ShowMenu(void);
    332336
  • programs/mythbackend/mainserver.cpp

     
    15191519        (pginfo->filesize > 0) &&
    15201520        (!ds->forceMetadataDelete))
    15211521    {
    1522         VERBOSE(VB_IMPORTANT, QString("ERROR when trying to delete file: %1. File "
    1523                                 "doesn't exist.  Database metadata"
    1524                                 "will not be removed.")
    1525                                 .arg(ds->filename));
     1522        VERBOSE(VB_IMPORTANT, QString(
     1523                    "ERROR when trying to delete file: %1. File "
     1524                    "doesn't exist.  Database metadata"
     1525                    "will not be removed.")
     1526                .arg(ds->filename));
    15261527        gContext->LogEntry("mythbackend", LP_WARNING, "Delete Recording",
    15271528                           QString("File %1 does not exist for %2 when trying "
    15281529                                   "to delete recording.")
    1529                                    .arg(ds->filename).arg(logInfo));
     1530                           .arg(ds->filename).arg(logInfo));
    15301531
    15311532        pginfo->SetDeleteFlag(false);
    1532         MythEvent me("RECORDING_LIST_CHANGE");
    1533         gContext->dispatch(me);
    1534 
    15351533        return;
    15361534    }
    15371535
     
    15771575                                   .arg(ds->filename).arg(logInfo));
    15781576
    15791577        pginfo->SetDeleteFlag(false);
    1580 
    1581         MythEvent me("RECORDING_LIST_CHANGE");
    1582         gContext->dispatch(me);
    1583 
    15841578        return;
    15851579    }
    15861580
     
    17151709
    17161710    // Notify the frontend so it can requery for Free Space
    17171711    QString msg = QString("RECORDING_LIST_CHANGE DELETE %1 %2")
    1718                           .arg(ds->chanid)
    1719                           .arg(ds->recstartts.toString(Qt::ISODate));
    1720     MythEvent me(msg);
    1721     gContext->dispatch(me);
     1712        .arg(ds->chanid).arg(ds->recstartts.toString(Qt::ISODate));
     1713    RemoteSendEvent(MythEvent(msg));
    17221714
    17231715    // sleep a little to let frontends reload the recordings list
    17241716    sleep(3);
     
    21092101            DoHandleStopRecording(recinfo, NULL);
    21102102        QStringList outputlist( QString::number(0) );
    21112103        SendResponse(pbssock, outputlist);
    2112         MythEvent me("RECORDING_LIST_CHANGE");
    2113         gContext->dispatch(me);
    21142104        return;
    21152105    }
    21162106
     
    22332223    // Tell MythTV frontends that the recording list needs to be updated.
    22342224    if ((fileExists) || (recinfo.filesize == 0) || (forceMetadataDelete))
    22352225    {
    2236         QString msg = QString("RECORDING_LIST_CHANGE DELETE %1 %2")
    2237                               .arg(recinfo.chanid)
    2238                               .arg(recinfo.recstartts.toString(Qt::ISODate));
    2239         MythEvent me(msg);
    2240         gContext->dispatch(me);
     2226        recinfo.SendDeletedEvent();
    22412227    }
    22422228}
    22432229
     
    22642250        recinfo.UpdateLastDelete(false);
    22652251        recinfo.SetAutoExpire(kDisableAutoExpire);
    22662252        ret = 0;
    2267         MythEvent me("RECORDING_LIST_CHANGE");
    2268         gContext->dispatch(me);
    22692253    }
    22702254
    22712255    QStringList outputlist( QString::number(ret) );
     
    42444228
    42454229    QString message = slist[1];
    42464230    QStringList extra_data;
    4247     for (uint i = 2; i < slist.size(); i++)
     4231    for (uint i = 2; i < (uint) slist.size(); i++)
    42484232        extra_data.push_back(slist[i]);
    42494233
    42504234    if (extra_data.empty())
  • programs/mythlcdserver/lcdprocclient.cpp

     
    23762376    {
    23772377        MythEvent *me = (MythEvent *) e;
    23782378
    2379         if (me->Message().left(21) == "RECORDING_LIST_CHANGE")
     2379        if (me->Message().left(21) == "RECORDING_LIST_CHANGE" ||
     2380            me->Message() == "UPDATE_PROG_INFO")
    23802381        {
    23812382            if (lcd_showrecstatus && !updateRecInfoTimer->isActive())
    23822383            {
  • programs/mythwelcome/welcomedialog.cpp

     
    151151    {
    152152        MythEvent *me = (MythEvent *) e;
    153153
    154         if (me->Message().left(21) == "RECORDING_LIST_CHANGE")
     154        if (me->Message().left(21) == "RECORDING_LIST_CHANGE" ||
     155            me->Message() == "UPDATE_PROG_INFO")
    155156        {
    156             VERBOSE(VB_GENERAL, "MythWelcome received a RECORDING_LIST_CHANGE event");
     157            VERBOSE(VB_GENERAL, "MythWelcome received a "
     158                    "recording list change event");
    157159
    158160            QMutexLocker lock(&m_RecListUpdateMuxtex);
    159161