Ticket #7691: 7691-v3.patch

File 7691-v3.patch, 23.3 KB (added by danielk, 10 years ago)

Updated patch -- down to one full reload.

  • 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

     
    376376    // Translations for play,recording, & storage groups +
    377377    static QString i18n(const QString&);
    378378
     379    /// Sends event out that the ProgramInfo should be reloaded.
     380    void SendUpdateEvent(void) const;
     381    /// Sends event out that the ProgramInfo should be added to lists.
     382    void SendAddedEvent(void) const;
     383    /// Sends event out that the ProgramInfo should be delete from lists.
     384    void SendDeletedEvent(void) const;
     385
    379386  protected:
    380387    // Creates a basename from the start and end times
    381388    QString CreateRecordBasename(const QString &ext) const;
    382     /// Sends event out that the ProgramInfo should be reloaded.
    383     void Update(void) const;
    384389
    385390  public:
    386391    // data
  • libs/libmyth/programinfo.cpp

     
    15501550        return false;
    15511551    }
    15521552
    1553     Update();
     1553    SendUpdateEvent();
    15541554    return true;
    15551555}
    15561556
     
    16731673    if (!query.exec() || !query.isActive())
    16741674        MythDB::DBError("File size update", query);
    16751675
    1676     Update();
     1676    SendUpdateEvent();
    16771677}
    16781678
    16791679/** \fn ProgramInfo::GetFilesize(void)
     
    17591759            MythDB::DBError("bookmark flag update", query);
    17601760    }
    17611761
    1762     Update();
     1762    SendUpdateEvent();
    17631763}
    17641764
    1765 void ProgramInfo::Update(void) const
     1765void ProgramInfo::SendUpdateEvent(void) const
    17661766{
    17671767    QStringList list;
    17681768    ToStringList(list);
    1769     MythEvent me(QString("UPDATE_PROG_INFO"), list);
    1770     RemoteSendEvent(me);
     1769    RemoteSendEvent(MythEvent(QString("UPDATE_PROG_INFO"), list));
    17711770}
    17721771
     1772void ProgramInfo::SendAddedEvent(void) const
     1773{
     1774    QStringList list;
     1775    ToStringList(list);
     1776    RemoteSendEvent(MythEvent(QString("RECORDING_LIST_CHANGE ADD"), list));
     1777}
     1778
     1779void ProgramInfo::SendDeletedEvent(void) const
     1780{
     1781    QString msg = QString("RECORDING_LIST_CHANGE DELETE %1 %2")
     1782        .arg(chanid).arg(recstartts.toString(Qt::ISODate));
     1783    RemoteSendEvent(MythEvent(msg));
     1784}
     1785
    17731786/** \brief Queries Latest bookmark timestamp from the database.
    17741787 *  If the timestamp has not been set this returns an invalid QDateTime.
    17751788 */
     
    18971910    if (!query.exec() || !query.isActive())
    18981911        MythDB::DBError("SetDVDBookmark updating", query);
    18991912
    1900     Update();
     1913    SendUpdateEvent();
    19011914}
    19021915/** \fn ProgramInfo::SetWatchedFlag(bool) const
    19031916 *  \brief Set "watched" field in recorded/videometadata to "watchedFlag".
     
    19581971            MythDB::DBError("Set watched flag", query);
    19591972    }
    19601973
    1961     Update();
     1974    SendUpdateEvent();
    19621975}
    19631976
    19641977/** \fn ProgramInfo::IsEditing(void) const
     
    20032016    if (!query.exec() || !query.isActive())
    20042017        MythDB::DBError("Edit status update", query);
    20052018
    2006     Update();
     2019    SendUpdateEvent();
    20072020}
    20082021
    20092022/** \fn ProgramInfo::SetDeleteFlag(bool) const
     
    20292042    if (!query.exec() || !query.isActive())
    20302043        MythDB::DBError("Set delete flag", query);
    20312044
    2032     Update();
     2045    if (!deleteFlag)
     2046        SendAddedEvent();
    20332047}
    20342048
    20352049/** \fn ProgramInfo::IsCommFlagged(void) const
     
    21462160    if(!query.exec() || !query.isActive())
    21472161        MythDB::DBError("Transcoded status update", query);
    21482162
    2149     Update();
     2163    SendUpdateEvent();
    21502164}
    21512165
    21522166/** \fn ProgramInfo::SetCommFlagged(int) const
     
    21682182    if (!query.exec() || !query.isActive())
    21692183        MythDB::DBError("Commercial Flagged status update", query);
    21702184
    2171     Update();
     2185    SendUpdateEvent();
    21722186}
    21732187
    21742188/** \fn ProgramInfo::SetPreserveEpisode(bool) const
     
    21922206    else
    21932207        UpdateLastDelete(false);
    21942208
    2195     Update();
     2209    SendUpdateEvent();
    21962210}
    21972211
    21982212/**
     
    22162230    else if (updateDelete)
    22172231        UpdateLastDelete(true);
    22182232
    2219     Update();
     2233    SendUpdateEvent();
    22202234}
    22212235
    22222236/** \fn ProgramInfo::UpdateLastDelete(bool) const
     
    23442358            MythDB::DBError("cutlist flag update", query);
    23452359    }
    23462360
    2347     Update();
     2361    SendUpdateEvent();
    23482362}
    23492363
    23502364void ProgramInfo::SetCommBreakList(frm_dir_map_t &frames) const
     
    34893503        recgroup = query.value(0).toString();
    34903504    }
    34913505
    3492     Update();
     3506    SendUpdateEvent();
    34933507}
    34943508
    34953509void ProgramInfo::MarkAsInUse(bool inuse, QString usedFor)
     
    35283542
    35293543    if (!inuse)
    35303544    {
    3531         if (!gContext->IsBackend())
    3532             RemoteSendMessage("RECORDING_LIST_CHANGE");
    35333545        inUseForWhat.clear();
     3546        SendUpdateEvent();
    35343547        return;
    35353548    }
    35363549
     
    35933606    query.bindValue(":RECHOST", hostname);
    35943607    query.bindValue(":RECDIR", recDir);
    35953608
    3596     if (!query.exec() || !query.isActive())
     3609    if (!query.exec())
    35973610        MythDB::DBError("SetInUse", query);
    35983611
    35993612    // Let others know we changed status
    3600     if (notifyOfChange && !gContext->IsBackend())
    3601         RemoteSendMessage("RECORDING_LIST_CHANGE");
     3613    if (notifyOfChange)
     3614        SendUpdateEvent();
    36023615}
    36033616
    36043617/** \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