Ticket #199: favorites_update.diff

libs/libmythtv/channelutil.cpp

@@ -1296 +1296 @@
                            dvb_transportid, dvb_networkid, dtv_si_std);
 }
 
-DBChanList ChannelUtil::GetChannels(uint sourceid, bool vis_only, QString grp)
+DBChanList ChannelUtil::GetChannels(uint sourceid, bool vis_only, QString grp, int favgrpid)
 {
     DBChanList list;
-    QMap<uint,uint> favorites;
     MSqlQuery query(MSqlQuery::InitCon());
-    query.prepare(
-        "SELECT chanid, favid "
-        "FROM favorites");
-    if (!query.exec() || !query.isActive())
-        MythContext::DBError("get channels -- favorites", query);
-    else
-    {
-        while (query.next())
-            favorites[query.value(0).toUInt()] = query.value(1).toUInt();
+    
+    QString qstr = "SELECT channum, callsign, channel.chanid, "
+           "       atsc_major_chan, atsc_minor_chan, "
+           "       name, icon, visible "
+           "FROM channel";
+
+
+    if (favgrpid > -1)
+    {
+       // Select only favorite channels from the specified group
+       
+       if (sourceid)
+           qstr += QString(",favorites WHERE sourceid='%1' AND ").arg(sourceid);
+       else
+           qstr += ",cardinput,capturecard,favorites "
+                   "WHERE cardinput.sourceid = channel.sourceid   AND "
+                   "      cardinput.cardid   = capturecard.cardid AND ";
+                   
+       qstr += QString("channel.chanid = favorites.chanid AND favorites.favgrpid ='%1' ").arg(favgrpid);
     }
-
-    QString qstr =
-        "SELECT channum, callsign, chanid, "
-        "       atsc_major_chan, atsc_minor_chan, "
-        "       name, icon, visible "
-        "FROM channel ";
-
-    if (sourceid)
-        qstr += QString("WHERE sourceid='%1' ").arg(sourceid);
     else
-        qstr += ",cardinput,capturecard "
-            "WHERE cardinput.sourceid = channel.sourceid   AND "
-            "      cardinput.cardid   = capturecard.cardid     ";
+    { 
+       // Select All channels
+       
+       if (sourceid)
+           qstr += QString(" WHERE sourceid='%1' ").arg(sourceid);
+       else
+           qstr += ",cardinput,capturecard "
+                   "WHERE cardinput.sourceid = channel.sourceid   AND "
+                   "      cardinput.cardid   = capturecard.cardid     ";
+    }
 
     if (vis_only)
         qstr += "AND visible=1 ";
@@ -1349 +1356 @@
             query.value(2).toUInt(),                      /* chanid     */
             query.value(3).toUInt(),                      /* ATSC major */
             query.value(4).toUInt(),                      /* ATSC minor */
-            favorites[query.value(2).toUInt()],           /* favid      */
+            0,                                            /* favid      */
             query.value(7).toBool(),                      /* visible    */
             QString::fromUtf8(query.value(5).toString()), /* name       */
             query.value(6).toString());                   /* icon       */
@@ -1519 +1526 @@
         } while ((it != start) && skip_non_visible && !it->visible);
 
     }
-    else if (CHANNEL_DIRECTION_UP == direction)
+    else if ((CHANNEL_DIRECTION_UP == direction) || (CHANNEL_DIRECTION_FAVORITE == direction))
     {
         do
         {
@@ -1528 +1535 @@
                 it = sorted.begin();
         } while ((it != start) && skip_non_visible && !it->visible);
     }
-    else if (CHANNEL_DIRECTION_FAVORITE == direction)
-    {
-        do
-        {
-            it++;
-            if (it == sorted.end())
-                it = sorted.begin();
-
-        } while ((it != start) &&
-                 (!it->favorite || (skip_non_visible && !it->visible)));
-    }
+//    else if (CHANNEL_DIRECTION_FAVORITE == direction)
+//    {
+//        do
+//        {
+//            it++;
+//            if (it == sorted.end())
+//                it = sorted.begin();
+
+//        } while ((it != start) &&
+//                 (!it->favorite || (skip_non_visible && !it->visible)));
+//    }
 
     return it->chanid;
 }

libs/libmythtv/channelutil.h

@@ -43 +43 @@
 };
 typedef vector<DBChannel> DBChanList;
 
-
 /** \class ChannelUtil
  *  \brief Collection of helper utilities for channel DB use
  */
@@ -164 +163 @@
     static QString GetVideoFilters(uint sourceid, const QString &channum)
         { return GetChannelValueStr("videofilters", sourceid, channum); }
 
-    static DBChanList GetChannels(uint srcid, bool vis_only, QString grp="");
+    static DBChanList GetChannels(uint srcid, bool vis_only, QString grp="", int favgrpid=-1);
     static void    SortChannels(DBChanList &list, const QString &order,
                                 bool eliminate_duplicates = false);
     static void    EliminateDuplicateChanNum(DBChanList &list);

libs/libmythtv/favoritegroup.cpp

@@ +1 @@
+#include "libmyth/mythcontext.h"
+#include "libmyth/mythdbcon.h"
+#include <qsqldatabase.h>
+#include <qheader.h>
+#include <qcursor.h>
+#include <qlayout.h>
+#include <iostream>
+#include "channelutil.h"
+#include "favoritegroup.h"
+
+#define LOC QString("Favorites: ")
+#define LOC_ERR QString("Favorites, Error: ")
+
+// Storage class for favorite group channel editor in settings
+class FavoriteStorage : public Storage
+{
+  public:
+    FavoriteStorage(Setting *_setting,
+                    uint _chanid, QString _grpname) :
+        setting(_setting), chanid(_chanid), grpname(_grpname) {}
+    virtual ~FavoriteStorage() {};
+
+    virtual void load(void);
+    virtual void save(void);
+    virtual void save(QString destination);
+
+  protected:
+    Setting *setting;
+    uint    chanid;
+    QString grpname;
+    int     grpid;
+};
+
+void FavoriteStorage::load(void)
+{
+    setting->setValue("0");
+    setting->setUnchanged();
+    
+    MSqlQuery query(MSqlQuery::InitCon());
+    
+    QString qstr = "SELECT favgrpid FROM favoritegroups WHERE name = :GRPNAME";
+   
+    query.prepare(qstr);
+    query.bindValue(":GRPNAME", grpname);
+
+    if (!query.exec() || !query.isActive())
+        MythContext::DBError("get favoriate Groups", query);
+    else 
+    {
+      query.next();
+      grpid = query.value(0).toUInt();
+    
+      qstr = "SELECT * FROM favorites WHERE favgrpid = :GRPID AND chanid = :CHANID";
+      query.prepare(qstr);
+      query.bindValue(":GRPID",  grpid);
+      query.bindValue(":CHANID", chanid);
+
+      if (!query.exec() || !query.isActive())
+          MythContext::DBError("get favoriate Groups", query);
+      else if (query.size() > 0)
+        setting->setValue("1");
+    }
+}
+
+void FavoriteStorage::save(void)
+{
+    if (!setting->isChanged())
+      return;
+    
+    QString value = setting->getValue();
+    
+    if (value == "1")
+        Favorites::ToggleFavorite(chanid, grpid, false);
+    else
+        Favorites::ToggleFavorite(chanid, grpid, true);   
+}
+
+void FavoriteStorage::save(QString destination)
+{
+    save();
+}
+
+FavoriteGroup& FavoriteGroup::operator=(const FavoriteGroup &other)
+{
+    grpid     = other.grpid;
+    name      = QDeepCopy<QString>(other.name);
+ 
+    return *this;
+}
+
+FavoriteGroup::FavoriteGroup(const FavoriteGroup &other)
+{
+    (*this) = other;
+}
+
+inline bool lt_group(const FavoriteGroup &a, const FavoriteGroup &b)
+{
+    return QString::localeAwareCompare(a.name, b.name) < 0;
+}
+
+bool Favorites::ToggleFavorite(uint chanid,int favgrpid, int delete_fav)
+{
+    // Check if favorite exists for that chanid...
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "SELECT favorites.favid "
+        "FROM favorites "
+        "WHERE favorites.chanid = :CHANID AND "
+        "favorites.favgrpid = :GRPID "
+        "LIMIT 1");
+    query.bindValue(":CHANID", chanid);
+    query.bindValue(":GRPID", favgrpid);
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythContext::DBError("togglechannelfavorite", query);
+        return false;
+    }
+    else if ((query.size() > 0) && delete_fav)
+    {
+        // We have a favorites record...Remove it to toggle...
+        query.next();
+        QString favid = query.value(0).toString();
+        query.prepare(
+            QString("DELETE FROM favorites "
+                    "WHERE favid = '%1'").arg(favid));
+        query.exec();
+        VERBOSE(VB_IMPORTANT, LOC + "Removing Favorite.");
+    }
+    else if (query.size() == 0)
+    {
+        // We have no favorites record...Add one to toggle...
+        query.prepare(
+            QString("INSERT INTO favorites (chanid,favgrpid) "
+                    "VALUES ('%1','%2')").arg(chanid).arg(favgrpid));
+        query.exec();
+        VERBOSE(VB_IMPORTANT, LOC + "Adding Favorite.");
+    }
+
+    return true;
+}
+
+FavoriteGroupList Favorites::GetFavoriteGroups(void)
+{
+    FavoriteGroupList list;
+    
+    MSqlQuery query(MSqlQuery::InitCon());
+    
+    QString qstr = "SELECT favgrpid, name FROM favoritegroups";
+   
+    query.prepare(qstr);
+
+    if (!query.exec() || !query.isActive())
+        MythContext::DBError("get favoriate Groups", query);
+    else
+    {
+        while (query.next())
+        {
+           FavoriteGroup group(query.value(0).toUInt(), 
+                               query.value(1).toString());
+           list.push_back(group);
+        }
+    }
+    
+    stable_sort(list.begin(), list.end(), lt_group);
+
+    return list;
+}
+
+// Cycle through the available groups, then all channels
+// Will cycle through to end then return -1
+// To signify all channels.
+int Favorites::GetNextFavoriteGroup(const FavoriteGroupList &sorted, int grpid)
+{
+    // If no groups return -1 for all channels
+    if (sorted.empty())
+      return -1;
+    
+    // If grpid is all channels (-1), then return the first grpid  
+    if (grpid == -1)
+      return sorted[0].grpid;
+      
+    FavoriteGroupList::const_iterator it = find(sorted.begin(), sorted.end(), grpid);
+
+    // If grpid is not in the list, return -1 for all channels
+    if (it == sorted.end())
+        return -1; 
+
+    ++it;
+
+    // If we reached the end, the next option is all channels (-1)
+    if (it == sorted.end())
+       return -1;
+
+    return it->grpid;
+}
+
+QString Favorites::GetFavoriteGroupName(const FavoriteGroupList &sorted, int grpid)
+{
+    // All Channels
+    if (grpid == -1)
+      return "All Channels";
+
+    FavoriteGroupList::const_iterator it = find(sorted.begin(), sorted.end(), grpid);
+        
+    // If grpid wasn't found, return blank.    
+    if (it == sorted.end())
+       return "";
+    else
+       return it->name;
+}
+
+class FavChannel : public CheckBoxSetting, public FavoriteStorage
+{
+  public:
+    FavChannel(const FavoriteChannelGroup& _parent, const uint chanid, const QString channum, 
+               const QString channame, const QString grpname):
+        CheckBoxSetting(this),
+        FavoriteStorage(this, chanid, grpname)
+    {
+        setLabel(QObject::tr(QString("%1 %2").arg(channum).arg(channame)));
+        setHelpText(QObject::tr("Select/Unselect channels for this channel favorite group"));
+    };
+};
+
+FavoriteChannelGroup::FavoriteChannelGroup(QString _name)
+    : name(_name)
+{
+    VerticalConfigurationGroup   *cgroup; 
+    HorizontalConfigurationGroup *columns; 
+
+    DBChanList chanlist = ChannelUtil::GetChannels(0, true, "channum, callsign");
+    ChannelUtil::SortChannels(chanlist, "channum", true);
+
+    DBChanList::iterator it = chanlist.begin();
+    int i,j = 0;
+    int p = 1;
+    int pages = (int)((float)chanlist.size() / 8.0 / 3.0 + 0.5);
+    
+    do 
+    {  
+        columns = new HorizontalConfigurationGroup(false,false,false,false);
+        columns->setLabel(getName() + " " + 
+                          QObject::tr("Channel Favorite Group - Page ") +
+                          QObject::tr(QString("%1 of %2").arg(p).arg(pages)));
+        
+        for (j = 0; ((j < 3) && (it < chanlist.end())); ++j)
+        {
+            cgroup = new VerticalConfigurationGroup(false,false,false,false);
+            
+            for (i = 0; ((i < 8) && (it < chanlist.end())); ++i)
+            {
+                cgroup->addChild(new FavChannel(*this, it->chanid, it->channum, it->name, _name));
+                ++it;
+            }
+            columns->addChild(cgroup);
+        }
+        
+        ++p;
+        addChild(columns);
+    } while (it < chanlist.end());
+
+}
+
+FavoriteGroupEditor::FavoriteGroupEditor(void) :
+    listbox(new ListBoxSetting(this)), lastValue("__CREATE_NEW_GROUP__")
+{
+    listbox->setLabel(tr("Channel Favorite Groups"));
+    addChild(listbox);
+}
+
+void FavoriteGroupEditor::open(QString name) 
+{
+    lastValue = name;
+    bool created = false;
+
+    if (name == "__CREATE_NEW_GROUP__")
+    {
+        name = "";
+        
+        bool ok = MythPopupBox::showGetTextPopup(gContext->GetMainWindow(), 
+            tr("Create New Channel Favorite Group"),
+            tr("Enter group name or press SELECT to enter text via the "
+               "On Screen Keyboard"), name);
+        if (!ok)
+            return;
+
+        MSqlQuery query(MSqlQuery::InitCon());
+        query.prepare("INSERT INTO favoritegroups (name) VALUES (:NAME);");
+        query.bindValue(":NAME", name.utf8());
+        if (!query.exec())
+            MythContext::DBError("FavoriteGroupEditor::open", query);
+        else
+            created = true;
+    }
+    
+    FavoriteChannelGroup group(name);
+    
+    if (group.exec() == QDialog::Accepted || !created)
+        lastValue = name;
+
+};
+
+void FavoriteGroupEditor::doDelete(void) 
+{
+    QString name = listbox->getValue();
+    if (name == "__CREATE_NEW_GROUP__")
+        return;
+
+    QString message = tr("Delete favorite group:") +
+        QString("\n'%1'?").arg(name);
+
+    int value = MythPopupBox::show2ButtonPopup(gContext->GetMainWindow(),
+                                               "", message,
+                                               tr("Yes, delete group"),
+                                               tr("No, Don't delete group"), 2);
+
+    if (value == 0)
+    {
+        MSqlQuery query(MSqlQuery::InitCon());
+
+        // Find out favorite group id
+        query.prepare("SELECT favgrpid FROM favoritegroups WHERE name = :NAME;");
+        query.bindValue(":NAME", name.utf8());
+        if (!query.exec())
+            MythContext::DBError("FavoriteGroupEditor::doDelete", query);
+        query.next();
+        uint grpid = query.value(0).toUInt();
+
+        // Delete favorite channels from favorites for this group
+        query.prepare("DELETE FROM favorites WHERE favgrpid = :GRPID;");
+        query.bindValue(":GRPID", grpid);
+        if (!query.exec())
+            MythContext::DBError("FavoriteGroupEditor::doDelete", query);
+        
+        // Now delete the group from favoritegroups
+        query.prepare("DELETE FROM favoritegroups WHERE name = :NAME;");
+        query.bindValue(":NAME", name.utf8());
+        if (!query.exec())
+            MythContext::DBError("FavoriteGroupEditor::doDelete", query);
+
+        lastValue = "__CREATE_NEW_GROUP__";
+        load();
+    }
+
+    listbox->setFocus();
+}
+
+void FavoriteGroupEditor::load(void)
+{
+    listbox->clearSelections();
+    
+    FavoriteGroupList favgrplist;
+
+    favgrplist = Favorites::GetFavoriteGroups();
+
+    FavoriteGroupList::iterator it;
+
+    for (it = favgrplist.begin(); it < favgrplist.end(); ++it)
+       listbox->addSelection(it->name);
+       
+    listbox->addSelection(tr("(Create new group)"), "__CREATE_NEW_GROUP__");
+
+    listbox->setValue(lastValue);
+}
+
+int FavoriteGroupEditor::exec(void)
+{
+    while (ConfigurationDialog::exec() == QDialog::Accepted)
+        open(listbox->getValue());
+
+    return QDialog::Rejected;
+}
+
+MythDialog* FavoriteGroupEditor::dialogWidget(MythMainWindow* parent,
+                                          const char* widgetName)
+{
+    dialog = ConfigurationDialog::dialogWidget(parent, widgetName);
+    connect(dialog, SIGNAL(menuButtonPressed()), this, SLOT(doDelete()));
+    connect(dialog, SIGNAL(deleteButtonPressed()), this, SLOT(doDelete()));
+    return dialog;
+}

libs/libmythtv/favoritegroup.h

@@ +1 @@
+#ifndef FAVORITEGROUP_H
+#define FAVORITEGROUP_H
+
+#include "qstringlist.h"
+#include "libmyth/settings.h"
+#include "libmyth/mythwidgets.h"
+
+class FavoriteGroup
+{
+  public:
+    FavoriteGroup(const FavoriteGroup&);
+    FavoriteGroup(const uint _grpid, 
+                  const QString &_name) :
+        grpid(_grpid), name(_name) {}
+
+    bool operator == (uint _grpid) const
+        { return grpid == _grpid; }
+
+    FavoriteGroup& operator=(const FavoriteGroup&);
+
+  public:
+    uint    grpid;
+    QString name;
+};
+typedef vector<FavoriteGroup> FavoriteGroupList;
+
+/** \class Favorites
+*/
+class MPUBLIC Favorites
+{
+  public:
+    // Favorite 
+    static FavoriteGroupList GetFavoriteGroups(void);
+    static bool              ToggleFavorite(uint chanid,int favgrpid, int delete_fav);
+    static int               GetNextFavoriteGroup(const FavoriteGroupList &sorted, int grpid);
+    static QString           GetFavoriteGroupName(const FavoriteGroupList &sorted, int grpid);
+
+    
+  private:
+
+};
+
+class MPUBLIC FavoriteChannelGroup: public ConfigurationWizard
+{
+ public:
+    FavoriteChannelGroup(QString _name);
+    QString getName(void) const { return name; }
+
+ private:
+    QString name;
+};
+
+class MPUBLIC FavoriteGroupEditor : public QObject, public ConfigurationDialog
+{
+    Q_OBJECT
+
+  public:
+    FavoriteGroupEditor(void);
+    virtual int exec(void);
+    virtual void load(void);
+    virtual void save(void) { };
+    virtual void save(QString) { };
+    virtual MythDialog* dialogWidget(MythMainWindow* parent,
+                                     const char* widgetName=0);
+
+  protected slots:
+    void open(QString name);
+    void doDelete(void);
+
+  protected:
+    ListBoxSetting *listbox;
+    QString         lastValue;
+};
+
+#endif

mythtv/libs/libmythtv/guidegrid.cpp

@@ -20 +20 @@
 
 #include "mythcontext.h"
 #include "mythdbcon.h"
-#include "guidegrid.h"
 #include "infostructs.h"
 #include "programinfo.h"
 #include "scheduledrecording.h"
@@ -32 +31 @@
 #include "customedit.h"
 #include "util.h"
 #include "remoteutil.h"
-#include "channelutil.h"
+#include "guidegrid.h"
 
 bool RunProgramGuide(uint &chanid, QString &channum,
                      bool thread, TV *player,
-                     bool allowsecondaryepg)
+                     bool allowsecondaryepg, int *favgrpid)
 {
     bool channel_changed = false;
+    int  favorite_group  = -1;
+    
+    if (favgrpid != NULL)
+      favorite_group = *favgrpid;
 
     if (thread)
         qApp->lock();
@@ -47 +50 @@
 
     GuideGrid *gg = new GuideGrid(gContext->GetMainWindow(),
                                   chanid, channum,
-                                  player, allowsecondaryepg, "guidegrid");
+                                  player, allowsecondaryepg, "guidegrid",
+                                  favorite_group);
 
     gg->Show();
 
@@ -70 +74 @@
 
     if (thread)
         qApp->lock();
-
+    
+    if (favgrpid != NULL)
+      *favgrpid = gg->GetFavGrp();
+    
     delete gg;
 
     gContext->removeCurrentLocation();
@@ -84 +91 @@
 GuideGrid::GuideGrid(MythMainWindow *parent,
                      uint chanid, QString channum,
                      TV *player, bool allowsecondaryepg,
-                     const char *name)
+                     const char *name, int favgrpid)
          : MythDialog(parent, name)
 {
     desiredDisplayChans = DISPLAY_CHANS = 6;
     DISPLAY_TIMES = 30;
     int maxchannel = 0;
     m_currentStartChannel = 0;
+    
+    m_favgrpid = favgrpid;
+    m_favgrplist = Favorites::GetFavoriteGroups();
 
     m_player = player;
 
@@ -105 +115 @@
     infoRect = QRect(0, 0, 0, 0);
     curInfoRect = QRect(0, 0, 0, 0);
     videoRect = QRect(0, 0, 0, 0);
+    favRect = QRect(0, 0, 0, 0);
 
     jumpToChannelEnabled = gContext->GetNumSetting("EPGEnableJumpToChannel", 0);
     jumpToChannelActive = false;
@@ -125 +136 @@
     if (m_player && m_player->IsRunning() && !allowsecondaryepg)
         videoRect = QRect(0, 0, 1, 1);
 
-    showFavorites = gContext->GetNumSetting("EPGShowFavorites", 0);
     gridfilltype = gContext->GetNumSetting("EPGFillType", UIGuideType::Alpha);
     if (gridfilltype < (int)UIGuideType::Alpha)
     { // update old settings to new fill types
@@ -181 +191 @@
             container->SetDrawFontShadow(false);
     }
 
+    container = theme->GetSet("favorite_group");
+    if (container)
+    {
+        UITextType *type = (UITextType *)container->GetType("favgroup");
+        QString favgroup;
+        
+        favgroup = Favorites::GetFavoriteGroupName(m_favgrplist, m_favgrpid);
+        
+        if (type)
+            type->SetText(favgroup);
+    }
+
     channelOrdering = gContext->GetSetting("ChannelOrdering", "channum");
     dateformat = gContext->GetSetting("ShortDateFormat", "ddd d");
     unknownTitle = gContext->GetSetting("UnknownTitle", "Unknown");
@@ -552 +574 @@
         curInfoRect = area;
     if (name.lower() == "current_video")
         videoRect = area;
+    if (name.lower() == "favorite_group")
+        favRect = area;
 }
 
 QString GuideGrid::GetChanNum(void)
@@ -611 +635 @@
     m_channelInfos.clear();
 
     DBChanList channels = ChannelUtil::GetChannels(0, true,
-                                                   "channum, callsign");
+                                                   "channum, callsign", m_favgrpid);
     ChannelUtil::SortChannels(channels, channelOrdering, true);
 
-    if (showFavorites)
-    {
-        DBChanList tmp;
-        for (uint i = 0; i < channels.size(); i++)
-        {
-            if (channels[i].favorite)
-                tmp.push_back(channels[i]);
-        }
-
-        if (!tmp.empty())
-            channels = tmp;
-    }
-
     bool startingset = false;
     for (uint i = 0; i < channels.size(); i++)
     {
@@ -634 +645 @@
         val.chanstr  = channels[i].channum;
         val.chanid   = channels[i].chanid;
         val.callsign = channels[i].callsign;
-        val.favid    = channels[i].favorite;
+//        val.favid    = channels[i].favorite;
         val.channame = channels[i].name;
         val.iconpath = channels[i].icon;
         val.iconload = false;
@@ -734 +745 @@
     }
 }
 
+void GuideGrid::fillFavGroupInfo(void)
+{
+    LayerSet   *container = NULL;
+    UITextType *type = NULL;
+    
+    container = theme->GetSet("favorite_group");
+    if (container)
+    {
+        type = (UITextType *)container->GetType("favgroup");
+        QString favgroup;
+        
+        favgroup = Favorites::GetFavoriteGroupName(m_favgrplist, m_favgrpid);
+        
+        if (type)
+            type->SetText(favgroup);
+    }
+}
+
 void GuideGrid::fillProgramRowInfos(unsigned int row)
 {
     LayerSet *container = NULL;
@@ -1010 +1039 @@
         paintPrograms(&p);
     if (r.intersects(curInfoRect))
         paintCurrentInfo(&p);
+    if (r.intersects(favRect))
+        paintFavGroupInfo(&p);
 
     // if jumpToChannel has its own rect, use that; otherwise use the date's rect
     if ((jumpToChannelHasRect && r.intersects(jumpToChannelRect)) ||
@@ -1123 +1154 @@
     p->drawPixmap(dr.topLeft(), pix);
 }
 
+void GuideGrid::paintFavGroupInfo(QPainter *p)
+{
+    QRect dr = favRect;
+    QPixmap pix(dr.size());
+    pix.fill(this, dr.topLeft());
+    QPainter tmp(&pix);
+
+    LayerSet *container = NULL;
+    container = theme->GetSet("favorite_group");
+    if (container)
+    {
+        container->Draw(&tmp, 1, m_context);
+        container->Draw(&tmp, 2, m_context);
+        container->Draw(&tmp, 3, m_context);
+        container->Draw(&tmp, 4, m_context);
+        container->Draw(&tmp, 5, m_context);
+        container->Draw(&tmp, 6, m_context);
+        container->Draw(&tmp, 7, m_context);
+        container->Draw(&tmp, 8, m_context);
+    }
+    tmp.end();
+    p->drawPixmap(dr.topLeft(), pix);
+}
+
 void GuideGrid::paintChannels(QPainter *p)
 {
     QRect cr = channelRect;
@@ -1180 +1235 @@
         }
 
         QString tmpChannelFormat = channelFormat;
-        if (chinfo->favid > 0)
-        {
-            tmpChannelFormat.insert(tmpChannelFormat.find('<'), "* ");
-            tmpChannelFormat.insert(tmpChannelFormat.find('>') + 1, " *");
-        }
+//        if (chinfo->favid > 0)
+//        {
+//            tmpChannelFormat.insert(tmpChannelFormat.find('<'), "* ");
+//            tmpChannelFormat.insert(tmpChannelFormat.find('>') + 1, " *");
+//        }
 
         if (type)
         {
@@ -1214 +1269 @@
         }
     }
 
+    if (m_channelInfos.size() == 0)
+    {
+       // if the user has selected a favorite list with no channels
+       // Reset the text and icon. This will display one blank line
+       // to show that the favorite group has no channels
+       if (type)
+       {
+         type->SetText(0, "");
+         type->ResetImage(0);
+       }
+    }
+
     if (container)
     {
         container->Draw(&tmp, 1, m_context);
@@ -1348 +1415 @@
 
 void GuideGrid::toggleGuideListing()
 {
-    showFavorites = (!showFavorites);
-    generateListings();
+    int oldfavgrpid = m_favgrpid;
+    
+    m_favgrpid = Favorites::GetNextFavoriteGroup(m_favgrplist, oldfavgrpid);
+    
+    if (oldfavgrpid != m_favgrpid)
+      generateListings();
+      
+    fillFavGroupInfo();
+    update(favRect);
 }
 
 void GuideGrid::generateListings()
@@ -1368 +1442 @@
     update(fullRect);
 }
 
+int GuideGrid::SelectFavoriteGroup()
+{
+    if (m_favgrplist.empty())
+    {
+      MythPopupBox::showOkPopup(gContext->GetMainWindow(), "",
+                                "You don't have any favorite groups defined");
+
+      return -1;
+    }
+    
+    MythPopupBox box(gContext->GetMainWindow(), "SelectFavoriteGroup Popup");
+    box.addLabel("Select Favorite Group");
+
+    for (uint i = 0; i < m_favgrplist.size(); i++)
+      box.addButton(m_favgrplist[i].name);
+
+    box.addButton(tr("Cancel"))->setFocus();
+
+    int ret = box.ExecPopup();
+    
+    // If the user cancelled, return a special value
+    if (ret < 0)
+      return -1;
+    else 
+      return m_favgrplist[ret].grpid;
+}
+
 void GuideGrid::toggleChannelFavorite()
 {
-    MSqlQuery query(MSqlQuery::InitCon());
+    int grpid;
+
+    if (m_favgrpid == -1)
+    {
+      grpid = SelectFavoriteGroup();
+      
+      if (grpid == -1)
+        return;
+    }
+    else
+      grpid = m_favgrpid;
 
     // Get current channel id, and make sure it exists...
     int chanNum = m_currentRow + m_currentStartChannel;
@@ -1381 +1492 @@
     if (chanNum < 0)
         chanNum = 0;
 
-    int favid = m_channelInfos[chanNum].favid;
     int chanid = m_channelInfos[chanNum].chanid;
-
-    if (favid > 0) 
-    {
-        query.prepare("DELETE FROM favorites WHERE favid = :FAVID ;");
-        query.bindValue(":FAVID", favid);
-        query.exec(); 
-    }
-    else
-    {
-        // We have no favorites record...Add one to toggle...
-        query.prepare("INSERT INTO favorites (chanid) VALUES (:FAVID);");
-        query.bindValue(":FAVID", chanid);
-        query.exec(); 
-    }
-
-    if (showFavorites)
-        generateListings();
+   
+    if (m_favgrpid == -1)
+       // If currently viewing all channels, allow to add only not delete
+       Favorites::ToggleFavorite(chanid, grpid, false);
     else
-    {
-        int maxchannel = 0;
-        DISPLAY_CHANS = desiredDisplayChans;
-        fillChannelInfos(false);
-        maxchannel = max((int)m_channelInfos.size() - 1, 0);
-        DISPLAY_CHANS = min(DISPLAY_CHANS, maxchannel + 1);
-
-        repaint(channelRect, false);
-    }
+       // Only allow delete if viewing the favorite group in question
+       Favorites::ToggleFavorite(chanid, grpid, true);
+      
+    // If viewing favorites, refresh because a channel was removed
+    if (m_favgrpid != -1)
+       generateListings();
 }
 
 void GuideGrid::cursorLeft()

libs/libmythtv/guidegrid.h

@@ -12 +12 @@
 #include "uitypes.h"
 #include "xmlparse.h"
 #include "libmythtv/programinfo.h"
+#include "libmythtv/favoritegroup.h"
+#include "libmythtv/favoritegroup.h"
 
 using namespace std;
 
@@ -29 +31 @@
 MPUBLIC
 bool RunProgramGuide(uint &startChanId, QString &startChanNum,
                      bool thread = false, TV *player = NULL,
-                     bool allowsecondaryepg = true);
+                     bool allowsecondaryepg = true, int *favgrpid = NULL);
 
 
 class GuideGrid : public MythDialog
@@ -39 +41 @@
     GuideGrid(MythMainWindow *parent,
               uint chanid = 0, QString channum = "",
               TV *player = NULL, bool allowsecondaryepg = true,
-              const char *name = "GuideGrid");
+              const char *name = "GuideGrid", int favgrpid = -1);
    ~GuideGrid();
 
     uint    GetChanID(void);
     QString GetChanNum(void);
+    int     GetFavGrp(void) {return m_favgrpid;}
 
   protected slots:
     void cursorLeft();
@@ -104 +107 @@
     void paintPrograms(QPainter *);
     void paintCurrentInfo(QPainter *);
     void paintInfo(QPainter *);
+    void paintFavGroupInfo(QPainter *p);
  
     void resizeImage(QPixmap *, QString);
     void LoadWindow(QDomElement &);
@@ -128 +132 @@
     QRect infoRect;
     QRect curInfoRect;
     QRect videoRect;
+    QRect favRect;
 
     void fillChannelInfos(bool gotostartchannel = true);
 
@@ -135 +140 @@
 
     void fillProgramInfos(void);
     void fillProgramRowInfos(unsigned int row);
+    
+    void fillFavGroupInfo(void);
 
     void setStartChannel(int newStartChannel);
 
     void createProgramLabel(int, int);
+    
+    int SelectFavoriteGroup();
 
     vector<ChannelInfo> m_channelInfos;
     TimeInfo *m_timeInfos[MAX_DISPLAY_TIMES];
@@ -157 +166 @@
     int m_currentCol;
 
     bool selectState;
-    bool showFavorites;
     QString channelFormat;
 
     int desiredDisplayChans;
@@ -180 +188 @@
     QTimer *videoRepaintTimer;
 
     bool keyDown;
+    
+    int     m_favgrpid;
+    FavoriteGroupList m_favgrplist;
 
     void jumpToChannelResetAndHide();
     void jumpToChannelCancel();

libs/libmythtv/libmythtv.pro

@@ -149 +149 @@
 HEADERS += playgroup.h              progdetails.h
 HEADERS += channeleditor.h          channelsettings.h
 HEADERS += previewgenerator.h       transporteditor.h
+HEADERS += favoritegroup.h
 
 SOURCES += programinfo.cpp          proglist.cpp
 SOURCES += storagegroup.cpp
@@ -171 +172 @@
 SOURCES += progdetails.cpp
 SOURCES += channeleditor.cpp        channelsettings.cpp
 SOURCES += previewgenerator.cpp     transporteditor.cpp
+SOURCES += favoritegroup.cpp 
 
 # DiSEqC
 HEADERS += diseqc.h                 diseqcsettings.h

libs/libmythtv/tv_play.cpp

@@ -81 +81 @@
     bool showDialogs = true;
     bool playCompleted = false;
     ProgramInfo *curProgram = NULL;
-    
 
     if (tvrec)
         curProgram = new ProgramInfo(*tvrec);
@@ -223 +222 @@
     
     bool allowrerecord = tv->getAllowRerecord();
     bool deleterecording = tv->getRequestDelete();
-    
+
+    tv->SaveFavoriteGroup();
+
     delete tv;
     
     if (curProgram)
@@ -268 +269 @@
             ">,.");
     REG_KEY("TV Frontend", "TOGGLEFAV", "Toggle the current channel as a "
             "favorite", "?");
-    REG_KEY("TV Frontend", "NEXTFAV", "Toggle showing all channels or just "
-            "favorites in the program guide.", "/");
+    REG_KEY("TV Frontend", "NEXTFAV", "Cycle through favorite groups and all channels "
+            "in the program guide.", "/,S");
     REG_KEY("TV Frontend", "CHANUPDATE", "Switch channels without exiting "
             "guide in Live TV mode.", "X");
     REG_KEY("TV Frontend", "VOLUMEDOWN", "Volume down", "[,{,F10");
@@ -608 +609 @@
     stickykeys           = gContext->GetNumSetting("StickyKeys");
     ff_rew_repos         = gContext->GetNumSetting("FFRewReposTime", 100)/100.0;
     ff_rew_reverse       = gContext->GetNumSetting("FFRewReverse", 1);
+    favorite_group_id    = gContext->GetNumSetting("FavoritesDefaultGroup", -1);
+    browse_favorites     = gContext->GetNumSetting("FavoritesChangeChannel", 0);
+    
+    if (browse_favorites && (favorite_group_id > -1))
+    {
+      m_channellist = ChannelUtil::GetChannels(0, true, "channum, callsign", favorite_group_id);
+      ChannelUtil::SortChannels(m_channellist, "channum", true);
+    }
+    
+    m_favgrplist  = Favorites::GetFavoriteGroups();
+
     int def[8] = { 3, 5, 10, 20, 30, 60, 120, 180 };
     for (uint i = 0; i < sizeof(def)/sizeof(def[0]); i++)
         ff_rew_speeds.push_back(
@@ -770 +782 @@
     }
 }
 
+void TV::SaveFavoriteGroup(void)
+{
+    int favgrpid          = gContext->GetNumSetting("FavoritesDefaultGroup", -1);
+    int remember_last_fav = gContext->GetNumSetting("FavoritesRememberLast", 0);
+
+    if (remember_last_fav && (favgrpid != favorite_group_id))
+       gContext->SaveSetting("FavoritesDefaultGroup", favorite_group_id); 
+}
+
 TVState TV::GetState(void) const
 {
     if (InStateChange())
@@ -4097 +4138 @@
 
 void TV::ToggleChannelFavorite(void)
 {
-    activerecorder->ToggleChannelFavorite();
+//    activerecorder->ToggleChannelFavorite();
 }
 
 void TV::ChangeChannel(int direction)
 {
     bool muted = false;
 
+    if ((browse_favorites || (direction == CHANNEL_DIRECTION_FAVORITE)) && 
+        (favorite_group_id > -1) && (direction != CHANNEL_DIRECTION_SAME))
+    {
+      uint    chanid;
+      
+      // Collect channel info
+      pbinfoLock.lock();
+      uint    old_chanid  = playbackinfo->chanid.toUInt();
+      pbinfoLock.unlock();
+
+      chanid = ChannelUtil::GetNextChannel(m_channellist, old_chanid, direction);
+
+      ChangeChannel(chanid, "");     
+      return;
+    } else if (direction == CHANNEL_DIRECTION_FAVORITE)
+       direction = CHANNEL_DIRECTION_UP;
+
     if (nvp)
     {
         AudioOutput *aud = nvp->getAudioOutput();
@@ -5133 +5191 @@
 
     bool changeChannel = false;
     ProgramInfo *nextProgram = NULL;
+    int favgrpid = favorite_group_id;
 
     if (StateIsLiveTV(GetState()))
     {
@@ -5147 +5206 @@
                     allowsecondary = nvp->getVideoOutput()->AllowPreviewEPG();
 
                 // Start up EPG
-                changeChannel = RunProgramGuide(chanid, channum, true, this, allowsecondary);
+                changeChannel = RunProgramGuide(chanid, channum, true, this, allowsecondary,
+                                                &favgrpid);
                 break;
             }
             case kPlaybackBox:
@@ -5189 +5249 @@
         {
             default:
             case kScheduleProgramGuide:
-                RunProgramGuide(chanid, channum, true);
+                RunProgramGuide(chanid, channum, true, NULL, true, &favgrpid);
                 break;
             case kScheduleProgramFinder:
                 RunProgramFind(true, false);
@@ -5239 +5299 @@
             DoPause();
     }
 
+    // if favorite group was changed in EPG update local info
+    if ((favgrpid != favorite_group_id) && (editType == kScheduleProgramGuide))
+    {
+      favorite_group_id = favgrpid;
+      
+      if (browse_favorites)
+      {
+          VERBOSE(VB_IMPORTANT, LOC + 
+             QString("Reloading favorite channel list for %1").arg(favorite_group_id));
+      
+          m_channellist = ChannelUtil::GetChannels(0, true, "channum, callsign", favorite_group_id);
+          ChannelUtil::SortChannels(m_channellist, "channum", true);
+      }
+    }
+
     // Resize the window back to the MythTV Player size
     if (!using_gui_size_for_tv)
     {
@@ -5863 +5938 @@
 {
     if (!browsemode)
         BrowseStart();
+VERBOSE(VB_IMPORTANT,"In BrowseDispInfo");
+    // if browsing favorites is enabled or direction if BROWSE_FAVORITES
+    // Then pick the next channel in the channel favorite list to browse
+    // If favorite group is ALL CHANNELS (-1), then bypass picking from 
+    // the channel favorite list
+    if ((browse_favorites || (direction == BROWSE_FAVORITE)) &&
+        (favorite_group_id > -1) && (direction != BROWSE_SAME) &&
+        (direction != BROWSE_RIGHT) && (direction != BROWSE_LEFT))
+    { 
+      uint chanid;
+      int  dir;
+      
+      if ( (direction == BROWSE_UP) || (direction == BROWSE_FAVORITE) )
+        dir = CHANNEL_DIRECTION_UP;
+      else if (direction == BROWSE_DOWN)
+        dir = CHANNEL_DIRECTION_DOWN;
+      else // this should never happen, but just in case
+        dir = direction;
+        
+      chanid = ChannelUtil::GetNextChannel(m_channellist, browsechanid.toUInt(), dir);
+      VERBOSE(VB_IMPORTANT, QString("Get channel: %1").arg(chanid));
+      browsechanid  = QString("%1").arg(chanid);
+      browsechannum = QString::null;
+      direction     = BROWSE_SAME;
+    }
+    else if ((favorite_group_id == -1) && (direction == BROWSE_FAVORITE))
+      direction = BROWSE_UP;
 
     InfoMap infoMap;
     QDateTime curtime  = QDateTime::currentDateTime();
@@ -6607 +6709 @@
     }
     else if (action == "GUIDE")
         EditSchedule(kScheduleProgramGuide);
+    else if (action.left(10) == "FAVORITES_")
+        processFavoritesEntry(action);
     else if (action == "FINDER")
         EditSchedule(kScheduleProgramFinder);
     else if (action == "SCHEDULE")
@@ -6701 +6805 @@
     }
 }
 
+void TV::processFavoritesEntry(QString action)
+{
+    if (action == "FAVORITES_ALL_CHANNELS")
+      favorite_group_id = -1;
+    else
+    {
+      action.remove("FAVORITES_");
+      favorite_group_id = action.toInt();
+         
+      if (browse_favorites)
+      {
+         m_channellist = ChannelUtil::GetChannels(0, true, "channum, callsign", favorite_group_id);
+         ChannelUtil::SortChannels(m_channellist, "channum", true);
+      }
+    }
+}
+
 void TV::ShowOSDTreeMenu(void)
 {
     BuildOSDTreeMenu();
@@ -6736 +6857 @@
             freeRecorders = RemoteGetFreeRecorderCount();
 
         item = new OSDGenericTree(treeMenu, tr("Program Guide"), "GUIDE");
+        item = new OSDGenericTree(treeMenu, tr("Favorites"), "FAVORITES");
+        subitem = new OSDGenericTree(item, tr("All Channels"), 
+                                     "FAVORITES_ALL_CHANNELS",
+                                     (favorite_group_id == -1) ? 1 : 0,
+                                     NULL, "FAVORITEGROUP");
+        
+        FavoriteGroupList::iterator it;
+        
+        for (it = m_favgrplist.begin(); it != m_favgrplist.end(); ++it)
+        {
+           QString name = QString("FAVORITES_%1").arg(it->grpid);
+           subitem = new OSDGenericTree(item, it->name, name, 
+                                       ((int)(it->grpid) == favorite_group_id) ? 1 : 0,
+                                        NULL, "FAVORITEGROUP");
+        }    
+
         if (!gContext->GetNumSetting("JumpToProgramOSD", 1))
         {
             item = new OSDGenericTree(treeMenu, tr("Jump to Program"));

libs/libmythtv/tv_play.h

@@ -16 +16 @@
 #include "util.h"
 #include "programinfo.h"
 #include "videoouttypes.h"
+#include "channelutil.h"
+#include "favoritegroup.h"
 
 #include <qobject.h>
 
@@ -191 +193 @@
     // Used by EPG
     void ChangeVolume(bool up);
     void ToggleMute(void);
+    
+    // Favorites
+    void SaveFavoriteGroup(void);
 
   public slots:
     void HandleOSDClosed(int osdType);
@@ -358 +363 @@
 
     void BuildOSDTreeMenu(void);
     void ShowOSDTreeMenu(void);
+    
+    void processFavoritesEntry(QString action);
 
     void UpdateLCD(void);
     void ShowLCDChannelInfo(void);
@@ -626 +633 @@
     // Network Control stuff
     QValueList<QString> networkControlCommands;
     QMutex ncLock;
+    
+    int favorite_group_id;
+    uint browse_favorites;
+    FavoriteGroupList m_favgrplist;
+    DBChanList m_channellist;
 };
 
 #endif

programs/mythfrontend/globalsettings.cpp

@@ -2805 +2805 @@
     return gc;
 }
 
-static HostCheckBox *EPGShowFavorites()
-{
-    HostCheckBox *gc = new HostCheckBox("EPGShowFavorites");
-    gc->setLabel(QObject::tr("Only display 'favorite' channels"));
-    gc->setHelpText(QObject::tr("If enabled, the EPG will initially display "
-                    "only the channels marked as favorites. Pressing "
-                    "\"4\" will toggle between displaying favorites and all "
-                    "channels."));
-    gc->setValue(false);
-    return gc;
-}
 
 static HostSpinBox *EPGChanDisplay()
 {
@@ -2843 +2832 @@
     return gc;
 }
 
+static HostCheckBox *FavoritesRememberLast()
+{
+    HostCheckBox *gc = new HostCheckBox("FavoritesRememberLast");
+    gc->setLabel(QObject::tr("Remember channel favorite group"));
+    gc->setHelpText(QObject::tr("If enabled, the EPG will initially display "
+                    "only the channels from the last favorite group selected. Pressing "
+                    "\"4\" will toggle favorites group."));
+    gc->setValue(false);
+    return gc;
+}
+
+static HostComboBox *FavoritesDefaultGroup()
+{
+    HostComboBox *gc = new HostComboBox("FavoritesDefaultGroup");
+    gc->setLabel(QObject::tr("Default channel favorite group"));
+
+    FavoriteGroupList favgrplist;
+
+    favgrplist = Favorites::GetFavoriteGroups();
+
+    gc->addSelection(QObject::tr("All Channels"), "-1");
+
+    FavoriteGroupList::iterator it;
+
+    for (it = favgrplist.begin(); it < favgrplist.end(); ++it)
+       gc->addSelection(it->name, QString("%1").arg(it->grpid));
+
+    gc->setHelpText(QObject::tr("The EPG will initially display "
+                    "only the channels from the last favorite group selected. Pressing "
+                    "\"4\" will toggle favorites group."));
+    gc->setValue(false);
+    return gc;
+}
+
+static HostCheckBox *FavoritesChangeChannel()
+{
+    HostCheckBox *gc = new HostCheckBox("FavoritesChangeChannel");
+    gc->setLabel(QObject::tr("Browse/Change channels with Favorites"));
+    gc->setHelpText(QObject::tr("If enabled, LiveTV will browse or change channels "
+                    "from the selected favorite group. \"All Channels\" "
+                    "favorite group may be selected to browse all channels."));
+    gc->setValue(false);
+    return gc;
+}
+
+// Favorite Settings
+class FavoriteSettings : public TriggeredConfigurationGroup
+{
+  public:
+    FavoriteSettings() : TriggeredConfigurationGroup(false, true, false, false)
+    {
+         setLabel(QObject::tr("Remember last channel favorite group"));
+         setUseLabel(false);
+
+         Setting* RememberFavoriteEnabled = FavoritesRememberLast();
+         addChild(RememberFavoriteEnabled);
+         setTrigger(RememberFavoriteEnabled);
+
+         ConfigurationGroup* settings = new VerticalConfigurationGroup(false);
+         settings->addChild(FavoritesDefaultGroup());
+         addTarget("0", settings);
+
+         // show nothing if RememberFavoriteEnabled is on
+         addTarget("1", new VerticalConfigurationGroup(true));
+     };
+};
+
 // General RecPriorities settings
 
 static GlobalCheckBox *GRSchedMoveHigher()
@@ -4524 +4580 @@
     general2->addChild(HDRingbufferSize());
     addChild(general2);
 
+    VerticalConfigurationGroup* fav = new VerticalConfigurationGroup(false);
+    fav->setLabel(QObject::tr("General (Favorites)"));
+    FavoriteSettings *favoritesettings = new FavoriteSettings();
+    fav->addChild(favoritesettings);
+    fav->addChild(FavoritesChangeChannel());
+    addChild(fav);
 }
 
 EPGSettings::EPGSettings()
 {
     VerticalConfigurationGroup* epg = new VerticalConfigurationGroup(false);
-    epg->setLabel(QObject::tr("Program Guide") + " 1/2");
+    epg->setLabel(QObject::tr("Program Guide") + " 1/3");
     epg->addChild(EPGFillType());
     epg->addChild(EPGShowCategoryColors());
     epg->addChild(EPGShowCategoryText());
     epg->addChild(EPGScrollType());
     epg->addChild(EPGShowChannelIcon());
-    epg->addChild(EPGShowFavorites());
     epg->addChild(WatchTVGuide());
     epg->addChild(EPGChanDisplay());
     epg->addChild(EPGTimeDisplay());
     addChild(epg);
 
     VerticalConfigurationGroup* gen = new VerticalConfigurationGroup(false);
-    gen->setLabel(QObject::tr("Program Guide") + " 2/2");
+    gen->setLabel(QObject::tr("Program Guide") + " 2/3");
     gen->addChild(UnknownTitle());
     gen->addChild(UnknownCategory());
     gen->addChild(DefaultTVChannel());
     gen->addChild(SelectChangesChannel());
     gen->addChild(EPGRecThreshold());
     gen->addChild(EPGEnableJumpToChannel());
-    addChild(gen);
+    addChild(gen);    
 }
 
 GeneralRecPrioritiesSettings::GeneralRecPrioritiesSettings()

programs/mythfrontend/main.cpp

@@ -47 +47 @@
 #include "statusbox.h"
 #include "lcddevice.h"
 #include "langsettings.h"
+#include "favoritegroup.h"
 
 #include "libmythui/myththemedmenu.h"
 #include "libmythui/myththemebase.h"
@@ -398 +399 @@
     {
         EPGSettings settings;
         settings.exec();
+    }
+    else if (sel == "settings favorites")
+    {
+        FavoriteGroupEditor editor;
+        editor.exec();
     } 
     else if (sel == "settings generalrecpriorities") 
     {

programs/mythfrontend/tv_settings.xml

@@ -80 +80 @@
       <text>Playback OSD</text>
       <action>SETTINGS OSD</action>
    </button>
+   
+   <button>
+      <type>TV_SETTINGS_FAVORITE</type>
+      <text>Channel Favorite Groups</text>
+      <action>SETTINGS FAVORITES</action>
+   </button>
 
    <button>
       <type>TV_SETTINGS_PLAYBACK_GROUPS</type>

themes/classic/tv_settings.xml

@@ -66 +66 @@
    </button>
 
    <button>
+      <type>TV_SETTINGS_FAVORITE</type>
+      <text>Channel Favorite Groups</text>
+      <action>SETTINGS FAVORITES</action>
+   </button>
+
+   <button>
       <type>TV_SETTINGS_PLAYBACK_GROUPS</type>
       <text>Playback Groups</text>
       <text lang="SV">Uppspelningsgrupper</text>

themes/DVR/tv_settings.xml

@@ -74 +74 @@
    </button>
 
    <button>
+      <type>TV_SETTINGS_FAVORITE</type>
+      <text>Channel Favorite Groups</text>
+      <action>SETTINGS FAVORITES</action>
+   </button>
+
+   <button>
       <type>TV_SETTINGS_PLAYBACK_GROUPS</type>
       <text>Playback Groups</text>
       <text lang="SV">Uppspelningsgrupper</text>