Ticket #10161: lazystrings_v1.patch

mythtv/libs/libmyth/programinfo.cpp

@@ -1320 +1320 @@
     return true;
 }
 
+const QString ProgramInfo::MakeString_titlesubtitle(const ProgramInfo *ths)
+{
+    QString tempSubTitle = ths->title;
+    if (!ths->subtitle.trimmed().isEmpty())
+    {
+        tempSubTitle = QString("%1 - \"%2\"")
+            .arg(tempSubTitle).arg(ths->subtitle);
+    }
+
+    return tempSubTitle;
+}
+
+const QString ProgramInfo::MakeString_s00e00(const ProgramInfo *ths)
+{
+    return QString("s%1e%2").arg(GetDisplaySeasonEpisode
+                                 (ths->GetSeason(), 2))
+        .arg(GetDisplaySeasonEpisode(ths->GetEpisode(), 2));
+}
+
+const QString ProgramInfo::MakeString_00x00(const ProgramInfo *ths)
+{
+    return QString("%1x%2").arg(GetDisplaySeasonEpisode
+                                (ths->GetSeason(), 1))
+        .arg(GetDisplaySeasonEpisode(ths->GetEpisode(), 2));
+}
+
+const QString ProgramInfo::MakeString_startdate(const ProgramInfo *ths)
+{
+    if (ths->IsVideo())
+    {
+        if (ths->startts.date().year() == 1895)
+            return "";
+        else
+            return ths->startts.toString("yyyy");
+    }
+    else
+    {
+        return MythDateTimeToString(ths->startts, kDateFull | kSimplify);
+    }
+}
+
+const QString ProgramInfo::MakeString_recstartdate(const ProgramInfo *ths)
+{
+    if (ths->IsVideo())
+    {
+        if (ths->startts.date().year() == 1895)
+            return "";
+        else
+            return ths->startts.toString("yyyy");
+    }
+    else
+    {
+        return MythDateTimeToString(ths->recstartts, kTime);
+    }
+}
+
+const QString ProgramInfo::MakeString_starttime(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->startts, kTime);
+}
+
+const QString ProgramInfo::MakeString_shortstartdate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->startts, kDateShort);
+}
+
+const QString ProgramInfo::MakeString_endtime(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->endts, kTime);
+}
+
+const QString ProgramInfo::MakeString_enddate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->endts, kDateFull | kSimplify);
+}
+
+const QString ProgramInfo::MakeString_shortenddate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->endts, kDateShort);
+}
+
+const QString ProgramInfo::MakeString_recstarttime(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recstartts, kTime);
+}
+
+const QString ProgramInfo::MakeString_recendtime(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recendts, kTime);
+}
+
+const QString ProgramInfo::MakeString_recenddate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recendts, kDateShort);
+}
+
+const QString ProgramInfo::MakeString_startts(const ProgramInfo *ths)
+{
+    return QString::number(ths->startts.toTime_t());
+}
+
+const QString ProgramInfo::MakeString_endts(const ProgramInfo *ths)
+{
+    return QString::number(ths->endts.toTime_t());
+}
+
+const QString ProgramInfo::MakeString_timedate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recstartts, kDateTimeFull | kSimplify) +
+        " - " + MythDateTimeToString(ths->recendts, kTime);
+}
+
+const QString ProgramInfo::MakeString_shorttimedate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recstartts, kDateTimeShort | kSimplify) +
+        " - " + MythDateTimeToString(ths->recendts, kTime);
+}
+
+const QString ProgramInfo::MakeString_starttimedate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recstartts, kDateTimeFull | kSimplify);
+}
+
+const QString ProgramInfo::MakeString_shortstarttimedate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->recstartts, kDateTimeShort | kSimplify);
+}
+
+const QString ProgramInfo::MakeString_lastmodifiedtime(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->lastmodified, kTime);
+}
+
+const QString ProgramInfo::MakeString_lastmodifieddate(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->lastmodified, kDateFull | kSimplify);
+}
+
+const QString ProgramInfo::MakeString_lastmodified(const ProgramInfo *ths)
+{
+    return MythDateTimeToString(ths->lastmodified, kDateTimeFull | kSimplify);
+}
+
+const QString ProgramInfo::MakeString_channel(const ProgramInfo *ths)
+{
+    QString channelFormat =
+        gCoreContext->GetSetting("ChannelFormat", "<num> <sign>");
+    return ths->ChannelText(channelFormat);
+}
+
+const QString ProgramInfo::MakeString_longchannel(const ProgramInfo *ths)
+{
+    QString longChannelFormat =
+        gCoreContext->GetSetting("LongChannelFormat", "<num> <name>");
+    return ths->ChannelText(longChannelFormat);
+}
+
+const QString ProgramInfo::MakeString_filesize_str(const ProgramInfo *ths)
+{
+    QString tmpSize;
+
+    tmpSize.sprintf("%0.2f ", ths->filesize * (1.0 / (1024.0 * 1024.0 * 1024.0)));
+    tmpSize += QObject::tr("GB", "GigaBytes");
+    return tmpSize;
+}
+
+const QString ProgramInfo::MakeString_lenmins(const ProgramInfo *ths)
+{
+    int minutes, seconds;
+    seconds = ths->recstartts.secsTo(ths->recendts);
+    minutes = seconds / 60;
+
+    QString min_str = QObject::tr("%n minute(s)","",minutes);
+
+    return min_str;
+}
+
+const QString ProgramInfo::MakeString_lentime(const ProgramInfo *ths)
+{
+    int hours, minutes, seconds;
+    seconds = ths->recstartts.secsTo(ths->recendts);
+    minutes = seconds / 60;
+
+    QString min_str = QObject::tr("%n minute(s)","",minutes);
+
+    hours   = minutes / 60;
+    minutes = minutes % 60;
+
+    if (hours > 0 && minutes > 0)
+    {
+        min_str = QObject::tr("%n minute(s)","",minutes);
+        return QString("%1 %2")
+            .arg(QObject::tr("%n hour(s)","", hours))
+            .arg(min_str);
+    }
+    else if (hours > 0)
+    {
+        return QObject::tr("%n hour(s)","", hours);
+    }
+
+    return min_str;
+}
+
+const QString ProgramInfo::MakeString_repeat(const ProgramInfo *ths)
+{
+    if (ths->IsRepeat())
+        return QString("(%1) ").arg(QObject::tr("Repeat"));
+    else
+        return "";
+}
+
+const QString ProgramInfo::MakeString_longrepeat(const ProgramInfo *ths)
+{
+    if (ths->IsRepeat())
+    {
+        if (ths->originalAirDate.isValid())
+            return QString("(%1 %2) ")
+                .arg(QObject::tr("Repeat"))
+                .arg(MythDateToString(ths->originalAirDate, kDateFull | kAddYear));
+        else
+            return QString("(%1) ").arg(QObject::tr("Repeat"));
+    }
+    else
+        return "";
+}
+
+const QString ProgramInfo::MakeString_originalairdate(const ProgramInfo *ths)
+{
+    if (!ths->originalAirDate.isValid() ||
+        (!ths->programid.isEmpty() && (ths->programid.left(2) == "MV")))
+        return "";
+    else
+        return MythDateToString(ths->originalAirDate, kDateFull);
+}
+
+const QString ProgramInfo::MakeString_shortoriginalairdate(const ProgramInfo *ths)
+{
+    if (!ths->originalAirDate.isValid() ||
+        (!ths->programid.isEmpty() && (ths->programid.left(2) == "MV")))
+        return "";
+    else
+        return MythDateToString(ths->originalAirDate, kDateShort);
+}
+
+void ProgramInfo::ToLazyMap(LazyInfoMap &progMap,
+                            bool showrerecord,
+                            uint star_range) const
+{
+    progMap["title"] = title;
+    progMap["subtitle"] = subtitle;
+    progMap["titlesubtitle"] = LazyMapEntry(MakeString_titlesubtitle, this);
+    progMap["description"] = description;
+    if (season > 0 || episode > 0)
+    {
+        progMap["season"] = QString::number(season);
+        progMap["episode"] = QString::number(episode);
+
+        progMap["s00e00"] = LazyMapEntry(MakeString_s00e00, this);
+        progMap["00x00"] = LazyMapEntry(MakeString_00x00, this);
+    }
+    progMap["category"] = category;
+    progMap["callsign"] = chansign;
+    progMap["commfree"] = QString((programflags & FL_CHANCOMMFREE) ? 1 : 0);
+    progMap["outputfilters"] = chanplaybackfilters;
+    if (IsVideo())
+    {
+        progMap["starttime"] = "";
+        //progMap["startdate"] = "";
+        progMap["endtime"] = "";
+        progMap["enddate"] = "";
+        progMap["recstarttime"] = "";
+        //progMap["recstartdate"] = "";
+        progMap["recendtime"] = "";
+        progMap["recenddate"] = "";
+        progMap["startdate"] = LazyMapEntry(MakeString_startdate, this);
+        progMap["recstartdate"] = LazyMapEntry(MakeString_recstartdate, this);
+    }
+    else // if (IsRecording())
+    {
+        progMap["starttime"] = LazyMapEntry(MakeString_starttime, this);
+        progMap["startdate"] = LazyMapEntry(MakeString_startdate, this);
+        progMap["shortstartdate"] = LazyMapEntry(MakeString_shortstartdate, this);
+        progMap["endtime"] = LazyMapEntry(MakeString_endtime, this);
+        progMap["enddate"] = LazyMapEntry(MakeString_enddate, this);
+        progMap["shortenddate"] = LazyMapEntry(MakeString_shortenddate, this);
+        progMap["recstarttime"] = LazyMapEntry(MakeString_recstarttime, this);
+        progMap["recstartdate"] = LazyMapEntry(MakeString_recstartdate, this);
+        progMap["recendtime"] = LazyMapEntry(MakeString_recendtime, this);
+        progMap["recenddate"] = LazyMapEntry(MakeString_recenddate, this);
+        progMap["startts"] = LazyMapEntry(MakeString_startts, this);
+        progMap["endts"]   = LazyMapEntry(MakeString_endts, this);
+    }
+
+    progMap["timedate"] = LazyMapEntry(MakeString_timedate, this);
+
+    progMap["shorttimedate"] = LazyMapEntry(MakeString_shorttimedate, this);
+
+    progMap["starttimedate"] = LazyMapEntry(MakeString_starttimedate, this);
+
+    progMap["shortstarttimedate"] = LazyMapEntry(MakeString_shortstarttimedate, this);
+
+    progMap["lastmodifiedtime"] = LazyMapEntry(MakeString_lastmodifiedtime, this);
+    progMap["lastmodifieddate"] = LazyMapEntry(MakeString_lastmodifieddate, this);
+    progMap["lastmodified"] = LazyMapEntry(MakeString_lastmodified, this);
+
+    progMap["channum"] = chanstr;
+    progMap["chanid"] = QString(chanid);
+    progMap["channame"] = channame;
+    progMap["channel"] = LazyMapEntry(MakeString_channel, this);
+    progMap["longchannel"] = LazyMapEntry(MakeString_longchannel, this);
+
+    progMap["filesize_str"] = LazyMapEntry(MakeString_filesize_str, this);
+    progMap["filesize"] = QString::number(filesize);
+
+    progMap["lenmins"] = LazyMapEntry(MakeString_lenmins, this);
+    progMap["lentime"] = LazyMapEntry(MakeString_lentime, this);
+
+    progMap["rectypechar"] = QString(toQChar(GetRecordingRuleType()));
+    progMap["rectype"] = ::toString(GetRecordingRuleType());
+
+    // Hard to compute rectypestatus lazily because of the use of
+    // showrerecord.
+    QString tmp_rec = ::toString(GetRecordingRuleType());
+    if (GetRecordingRuleType() != kNotRecording)
+    {
+        QDateTime timeNow = QDateTime::currentDateTime();
+        if (((recendts > timeNow) && (recstatus <= rsWillRecord)) ||
+            (recstatus == rsConflict) || (recstatus == rsLaterShowing))
+        {
+            tmp_rec += QString().sprintf(" %+d", recpriority);
+            if (recpriority2)
+                tmp_rec += QString().sprintf("/%+d", recpriority2);
+            tmp_rec += " ";
+        }
+        else
+        {
+            tmp_rec += " -- ";
+        }
+        if (showrerecord && (GetRecordingStatus() == rsRecorded) &&
+            !IsDuplicate())
+        {
+            tmp_rec += QObject::tr("Re-Record");
+        }
+        else
+        {
+            tmp_rec += ::toString(GetRecordingStatus(), GetRecordingRuleType());
+        }
+    }
+    progMap["rectypestatus"] = tmp_rec;
+
+    progMap["card"] = ::toString(GetRecordingStatus(), cardid);
+
+    progMap["recpriority"] = QString(recpriority);
+    progMap["recpriority2"] = QString(recpriority2);
+    progMap["recordingggroup"] = (recgroup == "Default")
+                                            ? QObject::tr("Default") : recgroup;
+    progMap["playgroup"] = playgroup;
+
+    if (storagegroup == "Default")
+        progMap["storagegroup"] = QObject::tr("Default");
+    else if (StorageGroup::kSpecialGroups.contains(storagegroup))
+        progMap["storagegroup"] = QObject::tr(storagegroup.toUtf8().constData());
+    else
+        progMap["storagegroup"] = storagegroup;
+
+    progMap["programflags"] = QString(programflags);
+
+    progMap["audioproperties"] = QString(GetAudioProperties());
+    progMap["videoproperties"] = QString(GetVideoProperties());
+    progMap["subtitleType"] = QString(GetSubtitleType());
+
+    progMap["recstatus"] = ::toString(GetRecordingStatus(),
+                                      GetRecordingRuleType());
+
+    progMap["repeat"] = LazyMapEntry(MakeString_repeat, this);
+    progMap["longrepeat"] = LazyMapEntry(MakeString_longrepeat, this);
+
+    progMap["seriesid"] = seriesid;
+    progMap["programid"] = programid;
+    progMap["inetref"] = inetref;
+    progMap["catType"] = catType;
+
+    progMap["year"] = year ? QString::number(year) : "";
+
+    QString star_str = (stars != 0.0f) ?
+        QObject::tr("%n star(s)", "", GetStars(star_range)) : "";
+    progMap["stars"] = star_str;
+    progMap["numstars"] = QString().number(GetStars(star_range));
+
+    if (stars != 0.0f && year)
+        progMap["yearstars"] = QString("(%1, %2)").arg(year).arg(star_str);
+    else if (stars != 0.0f)
+        progMap["yearstars"] = QString("(%1)").arg(star_str);
+    else if (year)
+        progMap["yearstars"] = QString("(%1)").arg(year);
+    else
+        progMap["yearstars"] = "";
+
+    progMap["originalairdate"] = LazyMapEntry(MakeString_originalairdate, this);
+    progMap["shortoriginalairdate"] = LazyMapEntry(MakeString_shortoriginalairdate, this);
+}
+
 /** \brief Converts ProgramInfo into QString QHash containing each field
  *         in ProgramInfo converted into localized strings.
  */

mythtv/libs/libmyth/programinfo.h

@@ -18 +18 @@
 #include "mythdbcon.h"
 #include "mythexp.h"
 
+#include "util.h" // for LazyInfoMap/LazyMapEntry
+
 /* If NUMPROGRAMLINES gets updated following files need
    updates and code changes:
    mythplugins/mythweb/classes/MythBackend.php
@@ -275 +277 @@
     virtual void ToMap(QHash<QString, QString> &progMap,
                        bool showrerecord = false,
                        uint star_range = 10) const;
+    virtual void ToLazyMap(LazyInfoMap &progMap,
+                       bool showrerecord = false,
+                       uint star_range = 10) const;
     virtual void SubstituteMatches(QString &str);
 
     // Used for scheduling recordings
@@ -710 +715 @@
 
     static QMutex staticDataLock;
     static ProgramInfoUpdater *updater;
+ public:
+    static const QString MakeString_titlesubtitle(const ProgramInfo *ths);
+    static const QString MakeString_s00e00(const ProgramInfo *ths);
+    static const QString MakeString_00x00(const ProgramInfo *ths);
+    static const QString MakeString_startdate(const ProgramInfo *ths);
+    static const QString MakeString_recstartdate(const ProgramInfo *ths);
+    static const QString MakeString_starttime(const ProgramInfo *ths);
+    static const QString MakeString_shortstartdate(const ProgramInfo *ths);
+    static const QString MakeString_endtime(const ProgramInfo *ths);
+    static const QString MakeString_enddate(const ProgramInfo *ths);
+    static const QString MakeString_shortenddate(const ProgramInfo *ths);
+    static const QString MakeString_recstarttime(const ProgramInfo *ths);
+    static const QString MakeString_recendtime(const ProgramInfo *ths);
+    static const QString MakeString_recenddate(const ProgramInfo *ths);
+    static const QString MakeString_startts(const ProgramInfo *ths);
+    static const QString MakeString_endts(const ProgramInfo *ths);
+    static const QString MakeString_timedate(const ProgramInfo *ths);
+    static const QString MakeString_shorttimedate(const ProgramInfo *ths);
+    static const QString MakeString_starttimedate(const ProgramInfo *ths);
+    static const QString MakeString_shortstarttimedate(const ProgramInfo *ths);
+    static const QString MakeString_lastmodifiedtime(const ProgramInfo *ths);
+    static const QString MakeString_lastmodifieddate(const ProgramInfo *ths);
+    static const QString MakeString_lastmodified(const ProgramInfo *ths);
+    static const QString MakeString_channel(const ProgramInfo *ths);
+    static const QString MakeString_longchannel(const ProgramInfo *ths);
+    static const QString MakeString_filesize_str(const ProgramInfo *ths);
+    static const QString MakeString_lenmins(const ProgramInfo *ths);
+    static const QString MakeString_lentime(const ProgramInfo *ths);
+    static const QString MakeString_repeat(const ProgramInfo *ths);
+    static const QString MakeString_longrepeat(const ProgramInfo *ths);
+    static const QString MakeString_originalairdate(const ProgramInfo *ths);
+    static const QString MakeString_shortoriginalairdate(const ProgramInfo *ths);
 };
 
 Q_DECLARE_METATYPE(ProgramInfo*)

mythtv/libs/libmythbase/util.h

@@ -143 +143 @@
 inline void rdtsc(uint64_t &x) { x = 0ULL; }
 #endif // !MMX
 
+class ProgramInfo;
+typedef const QString (*LazyMapFunc)(const ProgramInfo *);
+class LazyMapEntry {
+ public:
+    LazyMapEntry(LazyMapFunc f, const ProgramInfo *p)
+    : isComputed(false), value(), func(f), pi(p) {}
+    LazyMapEntry(const QString &v)
+    : isComputed(true), value(v), func(0), pi(0) {}
+    LazyMapEntry() {}
+    LazyMapEntry &operator=(const char *other) {
+        isComputed = true;
+        value = other;
+        return *this;
+    }
+    const QString &getValue(void) {
+        if (!isComputed) {
+            value = func(pi);
+            isComputed = true;
+        }
+        return value;
+    }
+ private:
+    bool isComputed;
+    QString value;
+    LazyMapFunc func;
+    const ProgramInfo *pi;
+};
+typedef QHash<QString,LazyMapEntry> LazyInfoMap;
+
 #endif // UTIL_H_

mythtv/libs/libmythui/mythgenerictree.cpp

@@ -746 +746 @@
 {
     if (!name.isEmpty())
     {
-        TextProperties textprop;
-        textprop.text = text;
-        textprop.state = state;
+        TextProperties textprop(text, state);
         m_strings.insert(name, textprop);
     }
     else
@@ -761 +759 @@
     QHash<QString, QString>::iterator map_it = infoMap.begin();
     while (map_it != infoMap.end())
     {
-        TextProperties textprop;
-        textprop.text = (*map_it);
-        textprop.state = state;
+        TextProperties textprop(*map_it, state);
         m_strings[map_it.key()] = textprop;
         ++map_it;
     }
 }
 
-QString MythGenericTree::GetText(const QString &name) const
+QString MythGenericTree::GetText(const QString &name)
 {
     if (name.isEmpty())
         return m_text;
     else if (m_strings.contains(name))
-        return m_strings[name].text;
+        return m_strings[name].text();
     else
         return QString();
 }

mythtv/libs/libmythui/mythgenerictree.h

@@ -73 +73 @@
     void SetText(const QString &text, const QString &name="",
                  const QString &state="");
     void SetTextFromMap(QHash<QString, QString> &infoMap, const QString &state="");
-    QString GetText(const QString &name="") const;
+    QString GetText(const QString &name="");
 
     void SetImage(const QString &filename, const QString &name="");
     QString GetImage(const QString &name="") const;

mythtv/libs/libmythui/mythscreentype.cpp

@@ -416 +416 @@
     DoSetTextFromMap((MythUIType*) this, infoMap);
 }
 
+static void DoSetTextFromLazyMap(MythUIType *UItype, LazyInfoMap &infoMap)
+{
+    QList<MythUIType *> *children = UItype->GetAllChildren();
+
+    MythUIText *textType;
+
+    QMutableListIterator<MythUIType *> i(*children);
+    while (i.hasNext())
+    {
+        MythUIType *type = i.next();
+        if (!type->IsVisible())
+            continue;
+
+        textType = dynamic_cast<MythUIText *> (type);
+        if (textType && infoMap.contains(textType->objectName()))
+            textType->SetTextFromLazyMap(infoMap);
+
+
+        MythUIGroup *group = dynamic_cast<MythUIGroup *> (type);
+        if (group)
+            DoSetTextFromLazyMap(type, infoMap);
+    }
+}
+
+void MythScreenType::SetTextFromLazyMap(LazyInfoMap &infoMap)
+{
+    DoSetTextFromLazyMap((MythUIType*) this, infoMap);
+}
+
 static void DoResetMap(MythUIType *UItype, QHash<QString, QString> &infoMap)
 {
     if (infoMap.isEmpty())

mythtv/libs/libmythui/mythscreentype.h

@@ -75 +75 @@
     bool IsLoaded(void) { return m_IsLoaded; }
 
     void SetTextFromMap(InfoMap &infoMap);
+    void SetTextFromLazyMap(LazyInfoMap &infoMap);
     void ResetMap(InfoMap &infoMap);
 
     virtual MythPainter *GetPainter(void);

mythtv/libs/libmythui/mythuibuttonlist.cpp

@@ -2746 +2746 @@
                 TextProperties props = item->m_strings[m_lcdColumns[x]];
 
                 if (text.isEmpty())
-                    text = props.text;
+                    text = props.text();
                 else
-                    text += " ~ " + props.text;
+                    text += " ~ " + props.text();
             }
             else
             {
@@ -2915 +2915 @@
 {
     if (!name.isEmpty())
     {
-        TextProperties textprop;
-        textprop.text = text;
-        textprop.state = state;
+        TextProperties textprop(text, state);
         m_strings.insert(name, textprop);
     }
     else
@@ -2934 +2932 @@
 
     while (map_it != infoMap.end())
     {
-        TextProperties textprop;
-        textprop.text = (*map_it);
-        textprop.state = state;
+        TextProperties textprop(*map_it, state);
+        m_strings[map_it.key()] = textprop;
+        ++map_it;
+    }
+
+    if (m_parent)
+        m_parent->Update();
+}
+
+void MythUIButtonListItem::SetTextFromLazyMap(LazyInfoMap &infoMap,
+                                              const QString &state)
+{
+    LazyInfoMap::iterator map_it = infoMap.begin();
+
+    while (map_it != infoMap.end())
+    {
+        TextProperties textprop(*map_it, state);
         m_strings[map_it.key()] = textprop;
         ++map_it;
     }
@@ -2951 +2963 @@
     m_strings = stringMap;
 }
 
-QString MythUIButtonListItem::GetText(const QString &name) const
+QString MythUIButtonListItem::GetText(const QString &name)
 {
     if (name.isEmpty())
         return m_text;
     else if (m_strings.contains(name))
-        return m_strings[name].text;
+        return m_strings[name].text();
     else
         return QString();
 }
 
 bool MythUIButtonListItem::FindText(const QString &searchStr, const QString &fieldList,
-                                    bool startsWith) const
+                                    bool startsWith)
 {
     if (fieldList.isEmpty())
     {
@@ -2984 +2996 @@
                 return true;
         }
 
-        QMap<QString, TextProperties>::const_iterator i = m_strings.constBegin();
+        QMap<QString, TextProperties>::iterator i = m_strings.begin();
 
-        while (i != m_strings.constEnd())
+        while (i != m_strings.end())
         {
             if (startsWith)
             {
-                if (i.value().text.startsWith(searchStr, Qt::CaseInsensitive))
+                if (i.value().text().startsWith(searchStr, Qt::CaseInsensitive))
                     return true;
             }
             else
             {
-                if (i.value().text.contains(searchStr, Qt::CaseInsensitive))
+                if (i.value().text().contains(searchStr, Qt::CaseInsensitive))
                     return true;
             }
 
@@ -3012 +3024 @@
             {
                 if (startsWith)
                 {
-                    if (m_strings[fields.at(x)].text.startsWith(searchStr, Qt::CaseInsensitive))
+                    if (m_strings[fields.at(x)].text().startsWith(searchStr, Qt::CaseInsensitive))
                         return true;
                 }
                 else
                 {
-                    if (m_strings[fields.at(x)].text.contains(searchStr, Qt::CaseInsensitive))
+                    if (m_strings[fields.at(x)].text().contains(searchStr, Qt::CaseInsensitive))
                         return true;
                 }
             }
@@ -3327 +3339 @@
                 {
                     QString key = regexp.cap(4).toLower().trimmed();
                     QString replacement;
-                    QString value = m_strings.value(key).text;
+                    QString value = m_strings[key].text();
 
                     if (!value.isEmpty())
                     {
                         replacement = QString("%1%2%3%4")
                                       .arg(regexp.cap(2))
                                       .arg(regexp.cap(3))
-                                      .arg(m_strings.value(key).text)
+                                      .arg(m_strings[key].text())
                                       .arg(regexp.cap(6));
                     }
 
@@ -3345 +3357 @@
                 newText = tempString;
             }
             else
-                newText = textprop.text;
+                newText = textprop.text();
 
             if (newText.isEmpty())
                 text->Reset();

mythtv/libs/libmythui/mythuibuttonlist.h

@@ -15 +15 @@
 class MythUIButtonList;
 class MythUIStateType;
 
-struct TextProperties {
-    QString text;
+class TextProperties {
+public:
+    TextProperties(const QString t, const QString s)
+        : state(s), value(LazyMapEntry(t)) {}
+    TextProperties(const LazyMapEntry &e, const QString s)
+        : state(s), value(e) {}
+    TextProperties() {}
+    const QString &text() { return value.getValue(); }
     QString state;
+private:
+    LazyMapEntry value;
 };
 
 class MUI_PUBLIC MythUIButtonListItem
@@ -43 +51 @@
     void SetText(const QString &text, const QString &name="",
                  const QString &state="");
     void SetTextFromMap(InfoMap &infoMap, const QString &state="");
+    void SetTextFromLazyMap(LazyInfoMap &infoMap, const QString &state="");
     void SetTextFromMap(QMap<QString, TextProperties> &stringMap);
-    QString GetText(const QString &name="") const;
+    QString GetText(const QString &name="");
 
     bool FindText(const QString &searchStr, const QString &fieldList = "**ALL**",
-                  bool startsWith = false) const;
+                  bool startsWith = false);
 
     void SetFontState(const QString &state, const QString &name="");
 

mythtv/libs/libmythui/mythuitext.cpp

@@ -176 +176 @@
     }
 }
 
+void MythUIText::SetTextFromLazyMap(LazyInfoMap &map)
+{
+    if (!IsVisible())
+        return;
+
+    if (map.contains(objectName()))
+    {
+        QString newText = GetTemplateText();
+
+        if (newText.isEmpty())
+            newText = GetDefaultText();
+
+        QRegExp regexp("%(([^\\|%]+)?\\||\\|(.))?(\\w+)(\\|(.+))?%");
+        regexp.setMinimal(true);
+
+        if (!newText.isEmpty() && newText.contains(regexp))
+        {
+            int pos = 0;
+            QString tempString = newText;
+
+            while ((pos = regexp.indexIn(newText, pos)) != -1)
+            {
+                QString key = regexp.cap(4).toLower().trimmed();
+                QString replacement;
+
+                if (!map[key].getValue().isEmpty())
+                {
+                    replacement = QString("%1%2%3%4")
+                                  .arg(regexp.cap(2))
+                                  .arg(regexp.cap(3))
+                                  .arg(map[key].getValue())
+                                  .arg(regexp.cap(6));
+                }
+
+                tempString.replace(regexp.cap(0), replacement);
+                pos += regexp.matchedLength();
+            }
+
+            newText = tempString;
+        }
+        else
+            newText = map[objectName()].getValue();
+
+        SetText(newText);
+    }
+}
+
 QString MythUIText::GetText(void) const
 {
     return m_Message;

mythtv/libs/libmythui/mythuitext.h

@@ -11 +11 @@
 // Mythui headers
 #include "mythuitype.h"
 
+#include "util.h" // for LazyInfoMap/LazyMapEntry
+
 class MythFontProperties;
 
 /**
@@ -39 +41 @@
     QString GetDefaultText(void) const;
 
     void SetTextFromMap(QHash<QString, QString> &map);
+    void SetTextFromLazyMap(LazyInfoMap &map);
 
     void SetTemplateText(const QString &text) { m_TemplateText = text; }
     QString GetTemplateText(void) const { return m_TemplateText; }

mythtv/programs/mythfrontend/playbackbox.cpp

@@ +1 @@
+// Uncomment the next line to disable use of lazy maps, e.g. for doing
+// timing comparisons.
+//#define USE_OLD_MAPS
 
 #include "playbackbox.h"
 
@@ -794 +797 @@
     // frontend
     if (m_groupList && m_groupList->GetItemCurrent())
     {
+#ifdef USE_OLD_MAPS
         InfoMap infoMap;
         pginfo->ToMap(infoMap);
         item->SetTextFromMap(infoMap);
+#else
+        LazyInfoMap infoMap;
+        pginfo->ToLazyMap(infoMap);
+        item->SetTextFromLazyMap(infoMap);
+#endif
 
         QString groupname =
             m_groupList->GetItemCurrent()->GetData().toString();
@@ -830 +839 @@
 
     if ((GetFocusWidget() == m_recordingList) && is_sel)
     {
+#ifdef USE_OLD_MAPS
         InfoMap infoMap;
 
         pginfo->ToMap(infoMap);
         ResetMap(m_currentMap);
         SetTextFromMap(infoMap);
         m_currentMap = infoMap;
+#else
+        LazyInfoMap infoMap;
+
+        pginfo->ToLazyMap(infoMap);
+        ResetMap(m_currentMap);
+        SetTextFromLazyMap(infoMap);
+        m_currentMap.clear();
+        for (LazyInfoMap::const_iterator it = infoMap.begin(); it != infoMap.end(); ++it)
+            m_currentMap[it.key()] = "<undefined>";
+#endif
 
         MythUIStateType *ratingState = dynamic_cast<MythUIStateType*>
                                                     (GetChild("ratingstate"));
@@ -1210 +1230 @@
 
 void PlaybackBox::UpdateUIGroupList(const QStringList &groupPreferences)
 {
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY UpdateUIGroupList begin"));
     m_groupList->Reset();
 
     if (!m_titleList.isEmpty())
@@ -1250 +1271 @@
         if (!sel_idx)
             updateRecList(m_groupList->GetItemCurrent());
     }
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY UpdateUIGroupList end"));
 }
 
 void PlaybackBox::updateRecList(MythUIButtonListItem *sel_item)
@@ -1298 +1320 @@
     subtitleFlags[SUB_HARDHEAR] = "cc";
 
     ProgramList::iterator it = progList.begin();
+    int tomapcount = 0;
     for (; it != progList.end(); ++it)
     {
         if ((*it)->GetAvailableStatus() == asPendingDelete ||
@@ -1311 +1334 @@
 
         item->SetFontState(state);
 
+#ifdef USE_OLD_MAPS
         InfoMap infoMap;
         (*it)->ToMap(infoMap);
         item->SetTextFromMap(infoMap);
+#else
+        LazyInfoMap infoMap;
+        (*it)->ToLazyMap(infoMap);
+        item->SetTextFromLazyMap(infoMap);
+#endif
+        ++tomapcount;
 
         QString tempSubTitle  = extract_subtitle(**it, groupname);
 
@@ -1347 +1377 @@
                 item->DisplayState(sit.value(), "subtitletypes");
         }
     }
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY ToMap count = %1").arg(tomapcount));
 
     if (m_noRecordingsText)
     {
@@ -1499 +1530 @@
 
 bool PlaybackBox::UpdateUILists(void)
 {
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY UpdateUILists() m_recGroup=%1 begin").arg(m_recGroup));
     m_isFilling = true;
 
     // Save selection, including next few items & groups
@@ -1546 +1578 @@
     QMap<int, QString> searchRule;
     QMap<int, int> recidEpisodes;
 
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY m_programInfoCache.Refresh() begin"));
     m_programInfoCache.Refresh();
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY m_programInfoCache.Refresh() end"));
 
     if (!m_programInfoCache.empty())
     {
@@ -2082 +2116 @@
 
     m_isFilling = false;
 
+    LOG(VB_GENERAL, LOG_INFO, QString("LZY UpdateUILists() end"));
     return true;
 }