Ticket #199: channelgroup.4.diff

libs/libmythtv/channelgroup.cpp

@@ +1 @@
+#include "mythcontext.h"
+#include "libmythdb/mythdbcon.h"
+#include <qsqldatabase.h>
+#include <qcursor.h>
+#include <qlayout.h>
+#include <iostream>
+#include "mythstorage.h"
+#include "mythdb.h"
+#include "channelutil.h"
+#include "channelgroup.h"
+
+#define LOC QString("Channel Group: ")
+#define LOC_ERR QString("Channel Group, Error: ")
+
+ChannelGroupItem& ChannelGroupItem::operator=(const ChannelGroupItem &other)
+{
+    grpid     = other.grpid;
+    name      = (other.name);
+ 
+    return *this;
+}
+
+ChannelGroupItem::ChannelGroupItem(const ChannelGroupItem &other)
+{
+    (*this) = other;
+}
+
+inline bool lt_group(const ChannelGroupItem &a, const ChannelGroupItem &b)
+{
+    return QString::localeAwareCompare(a.name, b.name) < 0;
+}
+
+bool ChannelGroup::ToggleChannel(uint chanid, int changrpid, int delete_chan)
+{
+    // Check if it already exists for that chanid...
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "SELECT channelgroup.id "
+        "FROM channelgroup "
+        "WHERE channelgroup.chanid = :CHANID AND "
+        "channelgroup.grpid = :GRPID "
+        "LIMIT 1");
+    query.bindValue(":CHANID", chanid);
+    query.bindValue(":GRPID", changrpid);
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("ChannelGroup::ToggleChannel", query);
+        return false;
+    }
+    else if ((query.size() > 0) && delete_chan)
+    {
+        // We have a record...Remove it to toggle...
+        query.next();
+        QString id = query.value(0).toString();
+        query.prepare(
+            QString("DELETE FROM channelgroup "
+                    "WHERE id = '%1'").arg(id));
+        query.exec();
+        VERBOSE(VB_IMPORTANT, LOC + QString("Removing channel with id=%1.").arg(id));
+    }
+    else if (query.size() == 0)
+    {
+        // We have no record...Add one to toggle...
+        query.prepare(
+            QString("INSERT INTO channelgroup (chanid,grpid) "
+                    "VALUES ('%1','%2')").arg(chanid).arg(changrpid));
+        query.exec();
+        VERBOSE(VB_IMPORTANT, LOC + QString("Adding channel %1 to group %2.").arg(chanid).arg(changrpid));
+    }
+
+    return true;
+}
+
+bool ChannelGroup::AddChannel(uint chanid, int changrpid)
+{
+    // Check if it already exists for that chanid...
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "SELECT channelgroup.id "
+        "FROM channelgroup "
+        "WHERE channelgroup.chanid = :CHANID AND "
+        "channelgroup.grpid = :GRPID "
+        "LIMIT 1");
+    query.bindValue(":CHANID", chanid);
+    query.bindValue(":GRPID", changrpid);
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("ChannelGroup::ToggleChannel", query);
+        return false;
+    }
+    else if (query.size() == 0)
+    {
+        // We have no record...Add one to toggle...
+        query.prepare(
+            QString("INSERT INTO channelgroup (chanid,grpid) "
+                    "VALUES ('%1','%2')").arg(chanid).arg(changrpid));
+        query.exec();
+        VERBOSE(VB_IMPORTANT, LOC + QString("Adding channel %1 to group %2.").arg(chanid).arg(changrpid));
+    }
+
+    return true;
+}
+
+bool ChannelGroup::DeleteChannel(uint chanid, int changrpid)
+{
+    // Check if it already exists for that chanid...
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "SELECT channelgroup.id "
+        "FROM channelgroup "
+        "WHERE channelgroup.chanid = :CHANID AND "
+        "channelgroup.grpid = :GRPID "
+        "LIMIT 1");
+    query.bindValue(":CHANID", chanid);
+    query.bindValue(":GRPID", changrpid);
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("ChannelGroup::ToggleChannel", query);
+        return false;
+    }
+    else if (query.size() > 0)
+    {
+        // We have a record...Remove it to toggle...
+        query.next();
+        QString id = query.value(0).toString();
+        query.prepare(
+            QString("DELETE FROM channelgroup "
+                    "WHERE id = '%1'").arg(id));
+        query.exec();
+        VERBOSE(VB_IMPORTANT, LOC + QString("Removing channel with id=%1.").arg(id));
+    }
+
+    return true;
+}
+
+ChannelGroupList ChannelGroup::GetChannelGroups(void)
+{
+    ChannelGroupList list;
+    
+    MSqlQuery query(MSqlQuery::InitCon());
+    
+    QString qstr = "SELECT grpid, name FROM channelgroupnames order by name";
+   
+    query.prepare(qstr);
+
+    if (!query.exec() || !query.isActive())
+        MythDB::DBError("ChannelGroup::GetChannelGroups", query);
+    else
+    {
+        while (query.next())
+        {
+           ChannelGroupItem 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 ChannelGroup::GetNextChannelGroup(const ChannelGroupList &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;
+      
+    ChannelGroupList::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 ChannelGroup::GetChannelGroupName(int grpid)
+{
+    // All Channels
+    if (grpid == -1)
+        return "All Channels";
+
+    MSqlQuery query(MSqlQuery::InitCon());
+    
+    QString qstr = QString("SELECT name FROM channelgroupnames where grpid='%1'")
+                   .arg(grpid);
+   
+    query.prepare(qstr);
+
+    if (!query.exec() || !query.isActive())
+        MythDB::DBError("ChannelGroup::GetChannelGroups", query);
+    else if (query.size() > 0)
+    {
+        query.next();    
+        return query.value(0).toString();
+    }
+    
+    return "";
+}
+
+int ChannelGroup::GetChannelGroupId(QString changroupname)
+{
+    // All Channels
+    if (changroupname == "All Channels")
+      return -1;
+
+    MSqlQuery query(MSqlQuery::InitCon());
+    
+    QString qstr = QString("SELECT grpid FROM channelgroupnames where name='%1'")
+                   .arg(changroupname);
+   
+    query.prepare(qstr);
+
+    if (!query.exec() || !query.isActive())
+        MythDB::DBError("ChannelGroup::GetChannelGroups", query);
+    else if (query.size() > 0)
+    {
+        query.next();    
+        return query.value(0).toUInt();
+    }
+    
+    return 0;
+}
+ No newline at end of file

libs/libmythtv/channelgroup.h

@@ +1 @@
+#ifndef CHANNELGROUP_H
+#define CHANNELGROUP_H
+
+class ChannelGroupItem
+{
+  public:
+    ChannelGroupItem(const ChannelGroupItem&);
+    ChannelGroupItem(const uint _grpid, 
+                  const QString &_name) :
+        grpid(_grpid), name(_name) {}
+
+    bool operator == (uint _grpid) const
+        { return grpid == _grpid; }
+
+    ChannelGroupItem& operator=(const ChannelGroupItem&);
+
+  public:
+    uint    grpid;
+    QString name;
+};
+typedef vector<ChannelGroupItem> ChannelGroupList;
+
+/** \class ChannelGroup
+*/
+class MPUBLIC ChannelGroup
+{
+  public:
+    // ChannelGroup 
+    static ChannelGroupList  GetChannelGroups(void);
+    static bool              ToggleChannel(uint chanid, int changrpid, int delete_chan);
+    static bool              AddChannel(uint chanid, int changrpid);
+    static bool              DeleteChannel(uint chanid, int changrpid);
+    static int               GetNextChannelGroup(const ChannelGroupList &sorted, int grpid);
+    static QString           GetChannelGroupName(int grpid);
+    static int               GetChannelGroupId(QString changroupname);
+    
+  private:
+
+};
+
+#endif

libs/libmythtv/channelgroupsettings.cpp

@@ +1 @@
+#include "mythcontext.h"
+#include "libmythdb/mythdbcon.h"
+#include <qsqldatabase.h>
+#include <qcursor.h>
+#include <qlayout.h>
+#include <iostream>
+#include "mythstorage.h"
+#include "mythdb.h"
+#include "channelutil.h"
+#include "channelgroup.h"
+#include "channelgroupsettings.h"
+
+#define LOC QString("Channel Group Settings: ")
+#define LOC_ERR QString("Channel Group Settings, Error: ")
+
+// Storage class for channel group editor in settings
+class ChannelGroupStorage : public Storage
+{
+  public:
+    ChannelGroupStorage(Setting *_setting,
+                    uint _chanid, QString _grpname) :
+        setting(_setting), chanid(_chanid), grpname(_grpname) {}
+    virtual ~ChannelGroupStorage() {};
+
+    virtual void Load(void);
+    virtual void Save(void);
+    virtual void Save(QString destination);
+
+  protected:
+    Setting *setting;
+    uint    chanid;
+    QString grpname;
+    int     grpid;
+};
+
+void ChannelGroupStorage::Load(void)
+{
+    setting->setValue("0");
+    
+    MSqlQuery query(MSqlQuery::InitCon());
+    
+    QString qstr = "SELECT grpid FROM channelgroupnames WHERE name = :GRPNAME";
+   
+    query.prepare(qstr);
+    query.bindValue(":GRPNAME", grpname);
+
+    if (!query.exec() || !query.isActive())
+        MythDB::DBError("ChannelGroupStorage::Load", query);
+    else 
+    {
+      query.next();
+      grpid = query.value(0).toUInt();
+    
+      qstr = "SELECT * FROM channelgroup WHERE grpid = :GRPID AND chanid = :CHANID";
+      query.prepare(qstr);
+      query.bindValue(":GRPID",  grpid);
+      query.bindValue(":CHANID", chanid);
+
+      if (!query.exec() || !query.isActive())
+          MythDB::DBError("ChannelGroupStorage::Load", query);
+      else if (query.size() > 0)
+        setting->setValue("1");
+    }
+}
+
+void ChannelGroupStorage::Save(void)
+{
+    QString value = setting->getValue();
+    
+    if (value == "1")
+        ChannelGroup::AddChannel(chanid, grpid);
+    else
+        ChannelGroup::DeleteChannel(chanid, grpid);   
+}
+
+void ChannelGroupStorage::Save(QString destination)
+{
+    Save();
+}
+
+class ChannelCheckBox : public CheckBoxSetting, public ChannelGroupStorage
+{
+  public:
+    ChannelCheckBox(const ChannelGroupConfig& _parent, const uint chanid, const QString channum, 
+               const QString channame, const QString grpname):
+        CheckBoxSetting(this),
+        ChannelGroupStorage(this, chanid, grpname)
+    {
+        setLabel(QString("%1 %2").arg(channum).arg(channame));
+        setHelpText(QObject::tr("Select/Unselect channels for this channel group"));
+    };
+};
+
+ChannelGroupConfig::ChannelGroupConfig(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 Group - Page ") + QString("%1").arg(p) +
+                          QObject::tr("of") + QString("%1").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 ChannelCheckBox(*this, it->chanid, it->channum, it->name, _name));
+                ++it;
+            }
+            columns->addChild(cgroup);
+        }
+        
+        ++p;
+        addChild(columns);
+    } while (it < chanlist.end());
+
+}
+
+ChannelGroupEditor::ChannelGroupEditor(void) :
+    listbox(new ListBoxSetting(this)), lastValue("__CREATE_NEW_GROUP__")
+{
+    listbox->setLabel(tr("Channel Groups"));
+    addChild(listbox);
+}
+
+void ChannelGroupEditor::open(QString name) 
+{
+    lastValue = name;
+    bool created = false;
+
+    if (name == "__CREATE_NEW_GROUP__")
+    {
+        name = "";
+        
+        bool ok = MythPopupBox::showGetTextPopup(gContext->GetMainWindow(), 
+            tr("Create New Channel 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 channelgroupnames (name) VALUES (:NAME);");
+        query.bindValue(":NAME", name);
+        if (!query.exec())
+            MythDB::DBError("ChannelGroupEditor::open", query);
+        else
+            created = true;
+    }
+    
+    ChannelGroupConfig group(name);
+    
+    if (group.exec() == QDialog::Accepted || !created)
+        lastValue = name;
+
+};
+
+void ChannelGroupEditor::doDelete(void) 
+{
+    QString name = listbox->getValue();
+    if (name == "__CREATE_NEW_GROUP__")
+        return;
+
+    QString message = tr("Delete '%1' Channel group?").arg(name);
+    
+    DialogCode value = MythPopupBox::Show2ButtonPopup(
+        gContext->GetMainWindow(),
+        "", message,
+        tr("Yes, delete group"),
+        tr("No, Don't delete group"), kDialogCodeButton1);
+
+    if (kDialogCodeButton0 == value)
+    {
+        MSqlQuery query(MSqlQuery::InitCon());
+
+        // Find out channel group id
+        query.prepare("SELECT grpid FROM channelgroupnames WHERE name = :NAME;");
+        query.bindValue(":NAME", name);
+        if (!query.exec())
+            MythDB::DBError("ChannelGroupEditor::doDelete", query);
+        query.next();
+        uint grpid = query.value(0).toUInt();
+
+        // Delete channels from this group
+        query.prepare("DELETE FROM channelgroup WHERE grpid = :GRPID;");
+        query.bindValue(":GRPID", grpid);
+        if (!query.exec())
+            MythDB::DBError("ChannelGroupEditor::doDelete", query);
+        
+        // Now delete the group from channelgroupnames
+        query.prepare("DELETE FROM channelgroupnames WHERE name = :NAME;");
+        query.bindValue(":NAME", name);
+        if (!query.exec())
+            MythDB::DBError("ChannelGroupEditor::doDelete", query);
+
+        lastValue = "__CREATE_NEW_GROUP__";
+        Load();
+    }
+
+    listbox->setFocus();
+}
+
+void ChannelGroupEditor::Load(void)
+{
+    listbox->clearSelections();
+    
+    ChannelGroupList changrplist;
+
+    changrplist = ChannelGroup::GetChannelGroups();
+
+    ChannelGroupList::iterator it;
+
+    for (it = changrplist.begin(); it < changrplist.end(); ++it)
+       listbox->addSelection(it->name);
+       
+    listbox->addSelection(tr("(Create new group)"), "__CREATE_NEW_GROUP__");
+
+    listbox->setValue(lastValue);
+}
+
+DialogCode ChannelGroupEditor::exec(void)
+{VERBOSE(VB_IMPORTANT, "ChannelGroupEditor::exec");
+    while (ConfigurationDialog::exec() == kDialogCodeAccepted)
+        open(listbox->getValue());
+
+    return kDialogCodeRejected;
+}
+
+MythDialog* ChannelGroupEditor::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/channelgroupsettings.h

@@ +1 @@
+#ifndef CHANNELGROUPSETTINGS_H
+#define CHANNELGROUPSETTINGS_H
+
+#include "libmyth/settings.h"
+
+class MPUBLIC ChannelGroupConfig: public ConfigurationWizard
+{
+ public:
+    ChannelGroupConfig(QString _name);
+    QString getName(void) const { return name; }
+
+ private:
+    QString name;
+};
+
+class MPUBLIC ChannelGroupEditor : public QObject, public ConfigurationDialog
+{
+    Q_OBJECT
+
+  public:
+    ChannelGroupEditor(void);
+    virtual DialogCode 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

libs/libmythtv/channelutil.cpp

@@ -1570 +1570 @@
     return true;
 }
 
-DBChanList ChannelUtil::GetChannels(uint sourceid, bool vis_only, QString grp)
+DBChanList ChannelUtil::GetChannels(uint sourceid, bool vis_only, QString grp, int changrpid)
 {
     DBChanList list;
-    QMap<uint,uint> favorites;
+    
     MSqlQuery query(MSqlQuery::InitCon());
-    query.prepare(
-        "SELECT chanid, favid "
-        "FROM favorites");
-    if (!query.exec() || !query.isActive())
-        MythDB::DBError("get channels -- favorites", query);
-    else
-    {
-        while (query.next())
-            favorites[query.value(0).toUInt()] = query.value(1).toUInt();
-    }
 
     QString qstr =
-        "SELECT channum, callsign, chanid, "
+        "SELECT channum, callsign, channel.chanid, "
         "       atsc_major_chan, atsc_minor_chan, "
         "       name, icon, mplexid, visible "
         "FROM channel ";
 
+    // Select only channels from the specified channel group
+    if (changrpid > -1)
+        qstr += QString(",channelgroup ");
+
     if (sourceid)
         qstr += QString("WHERE sourceid='%1' ").arg(sourceid);
     else
@@ -1599 +1593 @@
             "WHERE cardinput.sourceid = channel.sourceid   AND "
             "      cardinput.cardid   = capturecard.cardid     ";
 
+    if (changrpid > -1)
+    {
+        qstr += QString("AND channel.chanid = channelgroup.chanid "
+                        "AND channelgroup.grpid ='%1' ").arg(changrpid);
+    }
+
     if (vis_only)
         qstr += "AND visible=1 ";
 
@@ -1623 +1623 @@
             query.value(2).toUInt(),                      /* chanid     */
             query.value(3).toUInt(),                      /* ATSC major */
             query.value(4).toUInt(),                      /* ATSC minor */
-            favorites[query.value(2).toUInt()],           /* favid      */
             query.value(7).toUInt(),                      /* mplexid    */
             query.value(8).toBool(),                      /* visible    */
             query.value(5).toString(),                    /* name       */
@@ -1806 +1805 @@
                 (mplexid_restriction &&
                  (mplexid_restriction != it->mplexid))));
     }
-    else if (CHANNEL_DIRECTION_UP == direction)
+    else if ((CHANNEL_DIRECTION_UP == direction) || (CHANNEL_DIRECTION_FAVORITE == direction))
     {
         do
         {
@@ -1819 +1818 @@
                 (mplexid_restriction &&
                  (mplexid_restriction != it->mplexid))));
     }
-    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) ||
-                (mplexid_restriction &&
-                 (mplexid_restriction != it->mplexid))));
-    }
 
     return it->chanid;
 }

libs/libmythtv/channelutil.h

@@ -168 +168 @@
     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 changrpid=-1);
     static void    SortChannels(DBChanList &list, const QString &order,
                                 bool eliminate_duplicates = false);
     static void    EliminateDuplicateChanNum(DBChanList &list);

libs/libmythtv/dbchannelinfo.cpp

@@ -16 +16 @@
 DBChannel::DBChannel(
     const QString &_channum, const QString &_callsign,
     uint _chanid, uint _major_chan, uint _minor_chan,
-    uint _favorite, uint _mplexid, bool _visible,
+    uint _mplexid, bool _visible,
     const QString &_name, const QString &_icon) :
     channum(_channum),
     callsign(_callsign), chanid(_chanid),
     major_chan(_major_chan), minor_chan(_minor_chan),
-    favorite(_favorite), mplexid(_mplexid), visible(_visible),
+    mplexid(_mplexid), visible(_visible),
     name(_name), icon(_icon)
 {
     channum.detach();
@@ -39 +39 @@
     chanid     = other.chanid;
     major_chan = other.major_chan;
     minor_chan = other.minor_chan;
-    favorite   = other.favorite;
     mplexid    = (other.mplexid == 32767) ? 0 : other.mplexid;
     visible    = other.visible;
     name       = other.name; name.detach();

libs/libmythtv/dbchannelinfo.h

@@ -23 +23 @@
     DBChannel(const DBChannel&);
     DBChannel(const QString &_channum, const QString &_callsign,
               uint _chanid, uint _major_chan, uint _minor_chan,
-              uint _favorite, uint _mplexid, bool _visible,
+              uint _mplexid, bool _visible,
               const QString &_name, const QString &_icon);
     DBChannel& operator=(const DBChannel&);
 
@@ -36 +36 @@
     uint    chanid;
     uint    major_chan;
     uint    minor_chan;
-    uint    favorite;
     uint    mplexid;
     bool    visible;
     QString name;

libs/libmythtv/remoteencoder.cpp

@@ -402 +402 @@
     return (lastinput.isEmpty()) ? "Error" : lastinput;
 }
 
-void RemoteEncoder::ToggleChannelFavorite(void)
+void RemoteEncoder::ToggleChannelFavorite(QString changroupname)
 {
     QStringList strlist( QString("QUERY_RECORDER %1").arg(recordernum) );
     strlist << "TOGGLE_CHANNEL_FAVORITE";
+    strlist << changroupname;
 
     SendReceiveStringList(strlist);
 }

libs/libmythtv/remoteencoder.h

@@ -50 +50 @@
         PictureAdjustType type, PictureAttribute attr, bool up);
     void ChangeChannel(int channeldirection);
     void ChangeDeinterlacer(int deint_mode);
-    void ToggleChannelFavorite(void);
+    void ToggleChannelFavorite(QString);
     void SetChannel(QString channel);
     int  SetSignalMonitoringRate(int msec, bool notifyFrontend = true);
     uint GetSignalLockTimeout(QString input);

libs/libmythtv/tvosdmenuentry.cpp

@@ -202 +202 @@
     curMenuEntries.append(
         new TVOSDMenuEntry("JUMPREC",                 1,  1,  1,  0, "List of Recorded Shows"));
     curMenuEntries.append(
+        new TVOSDMenuEntry("CHANNELGROUP",            1,  1,  0,  0, "Channel Groups"));
+    curMenuEntries.append(
         new TVOSDMenuEntry("TOGGLEBROWSE",     1,  -1,  -1,  -1, "Live TV Browse Mode"));
     curMenuEntries.append(
         new TVOSDMenuEntry("PREVCHAN",              1,  -1,  -1,  -1, "Previous TV Channel"));

libs/libmythtv/tv_play.cpp

@@ -357 +357 @@
 
     bool allowrerecord = tv->getAllowRerecord();
     bool deleterecording = tv->getRequestDelete();
+    
+    tv->SaveChannelGroup();
 
     delete tv;
 
@@ -436 +438 @@
             "in the program guide", "0");
     REG_KEY("TV Frontend", "GUIDE", "Show the Program Guide", "S");
     REG_KEY("TV Frontend", "FINDER", "Show the Program Finder", "#");
-    REG_KEY("TV Frontend", "NEXTFAV", "Toggle showing all channels or just "
-            "favorites in the program guide.", "/");
+    REG_KEY("TV Frontend", "NEXTFAV", "Cycle through channel 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,Volume Down");
@@ -803 +805 @@
     osd_general_timeout  = gContext->GetNumSetting("OSDGeneralTimeout", 2);
     osd_prog_info_timeout= gContext->GetNumSetting("OSDProgramInfoTimeout", 3);
     tryUnflaggedSkip     = gContext->GetNumSetting("TryUnflaggedSkip", 0);
+    channel_group_id     = gContext->GetNumSetting("ChannelGroupDefault", -1);
+    browse_changrp       = gContext->GetNumSetting("BrowseChannelGroup", 0);
     smartForward         = gContext->GetNumSetting("SmartForward", 0);
     stickykeys           = gContext->GetNumSetting("StickyKeys");
     ff_rew_repos         = gContext->GetNumSetting("FFRewReposTime", 100)/100.0;
@@ -817 +821 @@
     if (!feVBI.isEmpty())
         vbimode = VBIMode::Parse(gContext->GetSetting(feVBI));
 
+    channel_group_id     = gContext->GetNumSetting("ChannelGroupDefault", -1);
+    browse_changrp       = gContext->GetNumSetting("BrowseChannelGroup", 0);
+    
+    if (browse_changrp && (channel_group_id > -1))
+    {
+      m_channellist = ChannelUtil::GetChannels(0, true, "channum, callsign", channel_group_id);
+      ChannelUtil::SortChannels(m_channellist, "channum", true);
+    }
+    
+    m_changrplist  = ChannelGroup::GetChannelGroups();
+
     if (createWindow)
     {
         bool fullscreen = !gContext->GetNumSetting("GuiSizeForTV", 0);
@@ -985 +1000 @@
 }
 
 /**
+ * \brief save channel group setting to database
+ */
+void TV::SaveChannelGroup(void)
+{
+    int remember_last_changrp = gContext->GetNumSetting("ChannelGroupRememberLast", 0);
+
+    if (remember_last_changrp)
+       gContext->SaveSetting("ChannelGroupDefault", channel_group_id); 
+}
+
+/**
  * \brief get tv state of active player context
  */
 TVState TV::GetState(int player_idx) const
@@ -4280 +4306 @@
         ToggleSleepTimer(ctx);
     else if (has_action("TOGGLERECORD", actions) && islivetv)
         ToggleRecord(ctx);
-    else if (has_action("TOGGLEFAV", actions) && islivetv)
-        ToggleChannelFavorite(ctx);
+//    else if (has_action("TOGGLEFAV", actions) && islivetv)
+//        ToggleChannelFavorite(ctx);
     else if (has_action("TOGGLECHANCONTROLS", actions) && islivetv)
         DoTogglePictureAttribute(ctx, kAdjustingPicture_Channel);
     else if (has_action("TOGGLERECCONTROLS", actions) && islivetv)
@@ -6256 +6282 @@
     UpdateOSDInput(ctx, inputname);
 }
 
-void TV::ToggleChannelFavorite(PlayerContext *ctx)
+void TV::ToggleChannelFavorite(PlayerContext *ctx, QString changroup_name)
 {
     if (ctx->recorder)
-        ctx->recorder->ToggleChannelFavorite();
+        ctx->recorder->ToggleChannelFavorite(changroup_name);
 }
 
 QString TV::GetQueuedInput(void) const
@@ -6514 +6540 @@
 {
     bool muted = false;
 
+    if ((browse_changrp || (direction == CHANNEL_DIRECTION_FAVORITE)) && 
+        (channel_group_id > -1) && (direction != CHANNEL_DIRECTION_SAME))
+    {
+       uint    chanid;
+
+       ctx->LockPlayingInfo(__FILE__, __LINE__);
+       if (!ctx->playingInfo)
+       {
+           VERBOSE(VB_IMPORTANT,
+                   LOC_ERR + "ChangeChannel(): no active ctx playingInfo.");
+           ctx->UnlockPlayingInfo(__FILE__, __LINE__);
+           ReturnPlayerLock(ctx);
+           return;
+       }
+
+       // Collect channel info
+       const ProgramInfo pginfo(*ctx->playingInfo);
+       uint    old_chanid  = pginfo.chanid.toUInt();
+       ctx->UnlockPlayingInfo(__FILE__, __LINE__);
+      
+       chanid = ChannelUtil::GetNextChannel(m_channellist, old_chanid, 0, direction);
+
+       ChangeChannel(ctx, chanid, "");     
+       return;
+    } else if (direction == CHANNEL_DIRECTION_FAVORITE)
+        direction = CHANNEL_DIRECTION_UP;
+
     QString oldinputname = ctx->recorder->GetInput();
 
     ctx->LockDeleteNVP(__FILE__, __LINE__);
@@ -7636 +7689 @@
     const ProgramInfo pginfo(*actx->playingInfo);
     uint    chanid  = pginfo.chanid.toUInt();
     QString channum = pginfo.chanstr;
+    int changrpid   = channel_group_id;
     actx->UnlockPlayingInfo(__FILE__, __LINE__);
 
     ClearOSD(actx);
@@ -7695 +7749 @@
         {
             TV *player = (pause_active) ? NULL : this;
             isEmbedded = (isLiveTV && player && allowEPG);
-            RunProgramGuidePtr(chanid, channum, player, true);
+            RunProgramGuidePtr(chanid, channum, player, true, changrpid);
             ignoreKeyPresses = true;
             break;
         }
@@ -7749 +7803 @@
         actx = GetPlayerReadLock(-1, __FILE__, __LINE__);
         StopEmbedding(actx);               // Undo any embedding
         DoSetPauseState(actx, saved_pause); // Restore pause states
+
         // If user selected a new channel in the EPG, change to that channel
         if (isLiveTV && changeChannel.size())
             ChangeChannel(actx, changeChannel);
@@ -8643 +8698 @@
     if (!browsemode)
         BrowseStart(ctx);
 
+    // if browsing channel groups is enabled or direction if BROWSE_FAVORITES
+    // Then pick the next channel in the channel group list to browse
+    // If channel group is ALL CHANNELS (-1), then bypass picking from 
+    // the channel group list
+    if ((browse_changrp || (direction == BROWSE_FAVORITE)) &&
+        (channel_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, 0, dir);
+      VERBOSE(VB_IMPORTANT, QString("Get channel: %1").arg(chanid));
+      browsechanid  = chanid;
+      browsechannum = QString::null;
+      direction     = BROWSE_SAME;
+    }
+    else if ((channel_group_id == -1) && (direction == BROWSE_FAVORITE))
+      direction = BROWSE_UP;
+      
     OSD *osd = GetOSDLock(ctx);
     if (ctx->paused || !osd)
     {
@@ -9546 +9628 @@
     }
     else if (action == "GUIDE")
         EditSchedule(actx, kScheduleProgramGuide);
+    else if (action.left(10) == "CHANGROUP_")
+    {
+        if (action == "CHANGROUP_ALL_CHANNELS")
+           channel_group_id = -1;
+        else
+        {
+           action.remove("CHANGROUP_");
+           channel_group_id = action.toInt();
+         
+           if (browse_changrp)
+           {
+               m_channellist = ChannelUtil::GetChannels(0, true, "channum, callsign", channel_group_id);
+               ChannelUtil::SortChannels(m_channellist, "channum", true);
+           }
+        }
+    }
     else if (action == "FINDER")
         EditSchedule(actx, kScheduleProgramFinder);
     else if (action == "SCHEDULE")
@@ -9743 +9841 @@
         if (lastProgram != NULL)
             new OSDGenericTree(jtp_item, lastProgram->title, "JUMPPREV");
     }
+    else if (category == "CHANNELGROUP")
+    {
+        FillMenuChanGroups(ctx, treeMenu);
+    }
     else if (category == "TOGGLEBROWSE")
     {
         if (!db_browse_always)
@@ -9797 +9899 @@
         FillMenuSleepMode(ctx, treeMenu);
 }
 
+void TV::FillMenuChanGroups(
+    const PlayerContext *ctx, OSDGenericTree *treeMenu) const
+{
+    OSDGenericTree *cg_item = new OSDGenericTree(treeMenu, tr("Channel Groups"), 
+                                                 "CHANGROUP");
+    new OSDGenericTree(cg_item, tr("All Channels"), "CHANGROUP_ALL_CHANNELS",
+                                (channel_group_id == -1) ? 1 : 0,
+                                NULL, "CHANNELGROUP");
+       
+    ChannelGroupList::const_iterator it;
+       
+    for (it = m_changrplist.begin(); it != m_changrplist.end(); ++it)
+    {
+        QString name = QString("CHANGROUP_%1").arg(it->grpid);
+        new OSDGenericTree(cg_item, it->name, name, 
+                           ((int)(it->grpid) == channel_group_id) ? 1 : 0,
+                           NULL, "CHANNELGROUP");
+    }
+}
+
 void TV::FillMenuPlaying(
     const PlayerContext *ctx, OSDGenericTree *treeMenu,
     QString category) const

libs/libmythtv/tv_play.h

@@ -25 +25 @@
 #include "videoouttypes.h"
 #include "volumebase.h"
 #include "inputinfo.h"
+#include "channelgroup.h"
 
 #include <qobject.h>
 
@@ -52 +53 @@
 typedef QMap<QString,DDValueMap> DDKeyMap;
 typedef ProgramInfo * (*EMBEDRETURNPROGRAM)(void *, bool);
 typedef void (*EMBEDRETURNVOID) (void *, bool);
-typedef void (*EMBEDRETURNVOIDEPG) (uint, const QString &, TV *, bool);
+typedef void (*EMBEDRETURNVOIDEPG) (uint, const QString &, TV *, bool, int);
 typedef void (*EMBEDRETURNVOIDFINDER) (TV *, bool);
 
 // Locking order
@@ -276 +277 @@
     bool HasUDPNotifyEvent(void) const;
     void HandleUDPNotifyEvent(void);
 
+    // Channel Groups
+    void SaveChannelGroup(void);
+
   public slots:
     void HandleOSDClosed(int osdType);
     void timerEvent(QTimerEvent*);
@@ -346 +350 @@
     void StopStuff(PlayerContext *mctx, PlayerContext *ctx,
                    bool stopRingbuffers, bool stopPlayers, bool stopRecorders);
 
-    void ToggleChannelFavorite(PlayerContext*);
+    void ToggleChannelFavorite(PlayerContext*, QString);
     void ChangeChannel(PlayerContext*, int direction);
     void ChangeChannel(PlayerContext*, uint chanid, const QString &channum);
     void PauseLiveTV(PlayerContext*);
@@ -527 +531 @@
     void FillMenuTimeStretch(   const PlayerContext*, OSDGenericTree*) const;
     void FillMenuSleepMode(     const PlayerContext*, OSDGenericTree*) const;
     bool FillMenuTracks(        const PlayerContext*, OSDGenericTree*, uint type) const;
+    void FillMenuChanGroups(    const PlayerContext *ctx, OSDGenericTree *treeMenu) const;
 
     void UpdateLCD(void);
     bool HandleLCDTimerEvent(void);
@@ -762 +767 @@
     QMap<int,int>             recorderPlaybackInfoTimerId;
     QMap<int,ProgramInfo>     recorderPlaybackInfo;
 
+    // Channel favorite group stuff    
+    int channel_group_id;
+    uint browse_changrp;
+    ChannelGroupList m_changrplist;
+    DBChanList m_channellist;
+
     // Network Control stuff
     MythDeque<QString> networkControlCommands;
 

libs/libmythtv/tv_rec.cpp

@@ -59 +59 @@
 #include "iptvrecorder.h"
 #include "firewirerecorder.h"
 
+#include "channelgroup.h"
+
 #ifdef USING_V4L
 #include "v4lchannel.h"
 #endif
@@ -2915 +2917 @@
 /** \fn TVRec::ToggleChannelFavorite()
  *  \brief Toggles whether the current channel should be on our favorites list.
  */
-void TVRec::ToggleChannelFavorite(void)
+void TVRec::ToggleChannelFavorite(QString changroupname)
 {
     QMutexLocker lock(&stateChangeLock);
 
@@ -2935 +2937 @@
                 "\t\t\tCould not toggle favorite.").arg(channum));
         return;
     }
-
-    // Check if favorite exists for that chanid...
-    MSqlQuery query(MSqlQuery::InitCon());
-    query.prepare(
-        "SELECT favorites.favid "
-        "FROM favorites "
-        "WHERE favorites.chanid = :CHANID "
-        "LIMIT 1");
-    query.bindValue(":CHANID", chanid);
-
-    if (!query.exec() || !query.isActive())
-    {
-        MythDB::DBError("togglechannelfavorite", query);
-    }
-    else if (query.size() > 0)
-    {
-        // 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_RECORD, LOC + "Removing Favorite.");
-    }
+    
+    int  changrpid;
+    bool result;
+    
+    changrpid = ChannelGroup::GetChannelGroupId(changroupname);
+    
+    if (changrpid <1)
+    {
+          VERBOSE(VB_RECORD, LOC + QString("ToggleChannelFavorite: Invalid "
+                   "channel group name %1, ").arg(changroupname));
+    }   
     else
     {
-        // We have no favorites record...Add one to toggle...
-        query.prepare(
-            QString("INSERT INTO favorites (chanid) "
-                    "VALUES ('%1')").arg(chanid));
-        query.exec();
-        VERBOSE(VB_RECORD, LOC + "Adding Favorite.");
+        result = ChannelGroup::ToggleChannel(chanid, changrpid, true);
+
+        if (!result)
+           VERBOSE(VB_RECORD, LOC + "Unable to toggle channel favorite.");
+        else
+           VERBOSE(VB_RECORD, LOC + QString("Toggled channel favorite."
+                   "channum %1, chan group %2").arg(channum).arg(changroupname));
     }
 }
 

libs/libmythtv/tv_rec.h

@@ -203 +203 @@
     QString GetChainID(void);
     void StopLiveTV(void);
     void PauseRecorder(void);
-    void ToggleChannelFavorite(void);
+    void ToggleChannelFavorite(QString);
 
     void SetLiveRecording(int recording);
 

programs/mythbackend/encoderlink.cpp

@@ -728 +728 @@
  *         <b>This only works on local recorders.</b>
  *  \return -1 if query does not succeed, otherwise.
  */
-void EncoderLink::ToggleChannelFavorite(void)
+void EncoderLink::ToggleChannelFavorite(QString changroup)
 {
     if (local)
-        tv->ToggleChannelFavorite();
+        tv->ToggleChannelFavorite(changroup);
     else
         VERBOSE(VB_IMPORTANT, "Should be local only query: ToggleChannelFavorite");
 }

programs/mythbackend/encoderlink.h

@@ -111 +111 @@
     vector<InputInfo> GetFreeInputs(const vector<uint> &excluded_cards) const;
     QString GetInput(void) const;
     QString SetInput(QString);
-    void ToggleChannelFavorite(void);
+    void ToggleChannelFavorite(QString);
     void ChangeChannel(int channeldirection);
     void SetChannel(const QString &name);
     int  GetPictureAttribute(PictureAttribute attr);

programs/mythbackend/mainserver.cpp

@@ -3259 +3259 @@
     }
     else if (command == "TOGGLE_CHANNEL_FAVORITE")
     {
-        enc->ToggleChannelFavorite();
+        QString changroup = slist[2];
+        enc->ToggleChannelFavorite(changroup);
         retlist << "ok";
     }
     else if (command == "CHANGE_CHANNEL")

programs/mythfrontend/globalsettings.cpp

@@ -3121 +3121 @@
     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 GlobalCheckBox *EPGEnableJumpToChannel()
 {
@@ -3143 +3132 @@
     return gc;
 }
 
+static HostCheckBox *ChannelGroupRememberLast()
+{
+    HostCheckBox *gc = new HostCheckBox("ChannelGroupRememberLast");
+    gc->setLabel(QObject::tr("Remember last channel group"));
+    gc->setHelpText(QObject::tr("If enabled, the EPG will initially display "
+                    "only the channels from the last channel group selected. Pressing "
+                    "\"4\" will toggle channel group."));
+    gc->setValue(false);
+    return gc;
+}
+
+static HostComboBox *ChannelGroupDefault()
+{
+    HostComboBox *gc = new HostComboBox("ChannelGroupDefault");
+    gc->setLabel(QObject::tr("Default channel group"));
+
+    ChannelGroupList changrplist;
+
+    changrplist = ChannelGroup::GetChannelGroups();
+
+    gc->addSelection(QObject::tr("All Channels"), "-1");
+
+    ChannelGroupList::iterator it;
+
+    for (it = changrplist.begin(); it < changrplist.end(); ++it)
+       gc->addSelection(it->name, QString("%1").arg(it->grpid));
+
+    gc->setHelpText(QObject::tr("Default channel group to be shown in the the EPG"
+                    "Pressing GUIDE key will toggle channel group."));
+    gc->setValue(false);
+    return gc;
+}
+
+static HostCheckBox *BrowseChannelGroup()
+{
+    HostCheckBox *gc = new HostCheckBox("BrowseChannelGroup");
+    gc->setLabel(QObject::tr("Browse/Change channels from Channel Group"));
+    gc->setHelpText(QObject::tr("If enabled, LiveTV will browse or change channels "
+                    "from the selected channel group. \"All Channels\" "
+                    "channel group may be selected to browse all channels."));
+    gc->setValue(false);
+    return gc;
+}
+
+// Channel Group Settings
+class ChannelGroupSettings : public TriggeredConfigurationGroup
+{
+  public:
+    ChannelGroupSettings() : TriggeredConfigurationGroup(false, true, false, false)
+    {
+         setLabel(QObject::tr("Remember last channel group"));
+         setUseLabel(false);
+
+         Setting* RememberChanGrpEnabled = ChannelGroupRememberLast();
+         addChild(RememberChanGrpEnabled);
+         setTrigger(RememberChanGrpEnabled);
+
+         ConfigurationGroup* settings = new VerticalConfigurationGroup(false,false);
+         settings->addChild(ChannelGroupDefault());
+         addTarget("0", settings);
+
+         // show nothing if RememberChanGrpEnabled is on
+         addTarget("1", new VerticalConfigurationGroup(true,false));
+     };
+};
+
 // General RecPriorities settings
 
 static GlobalCheckBox *GRSchedMoveHigher()
@@ -4909 +4964 @@
     general2->addChild(RecordOverTime());
     general2->addChild(CategoryOverTimeSettings());
     addChild(general2);
-
+    
+    VerticalConfigurationGroup* changrp = new VerticalConfigurationGroup(false);
+    changrp->setLabel(QObject::tr("General (Channel Groups)"));
+    ChannelGroupSettings *changroupsettings = new ChannelGroupSettings();
+    changrp->addChild(changroupsettings);
+    changrp->addChild(BrowseChannelGroup());
+    addChild(changrp);
 }
 
 EPGSettings::EPGSettings()
@@ -4919 +4980 @@
     epg->addChild(EPGShowCategoryColors());
     epg->addChild(EPGShowCategoryText());
     epg->addChild(EPGShowChannelIcon());
-    epg->addChild(EPGShowFavorites());
     epg->addChild(WatchTVGuide());
     addChild(epg);
 

programs/mythfrontend/guidegrid.cpp

@@ -174 +174 @@
 }
 
 void GuideGrid::RunProgramGuide(uint chanid, const QString &channum,
-                    TV *player, bool allowFinder)
+                    TV *player, bool allowFinder, int changrpid)
 {
     MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
     GuideGrid *gg = new GuideGrid(mainStack,
                                   chanid, channum,
-                                  player, allowFinder);
+                                  player, allowFinder, changrpid);
 
     if (gg->Create())
         mainStack->AddScreen(gg, (player == NULL));
@@ -189 +189 @@
 
 GuideGrid::GuideGrid(MythScreenStack *parent,
                      uint chanid, QString channum,
-                     TV *player, bool allowFinder) 
+                     TV *player, bool allowFinder, int changrpid) 
          : MythScreenType(parent, "guidegrid"),
     m_allowFinder(allowFinder),
     m_player(player),
@@ -207 +207 @@
     m_channelCount = 5;
     m_timeCount = 30;
     m_currentStartChannel = 0;
+    m_changrpid = changrpid;
+    m_changrplist = ChannelGroup::GetChannelGroups();
 
     m_jumpToChannelEnabled = gContext->GetNumSetting("EPGEnableJumpToChannel", 1);
-    m_showFavorites = gContext->GetNumSetting("EPGShowFavorites", 0);
     m_sortReverse = gContext->GetNumSetting("EPGSortReverse", 0);
     m_selectChangesChannel = gContext->GetNumSetting("SelectChangesChannel", 0);
     m_selectRecThreshold = gContext->GetNumSetting("SelChangeRecThreshold", 16);
@@ -258 +259 @@
     UIUtilE::Assign(this, m_channelList, "channellist", &err);
     UIUtilE::Assign(this, m_guideGrid, "guidegrid", &err);
     UIUtilW::Assign(this, m_dateText, "datetext");
+    UIUtilW::Assign(this, m_changroupname, "channelgroup");
     UIUtilW::Assign(this, m_channelImage, "channelicon");
     UIUtilW::Assign(this, m_jumpToText, "jumptotext");
 
@@ -300 +302 @@
 
     if (m_dateText)
         m_dateText->SetText(m_currentStartTime.toString(m_dateFormat));
+        
+    QString changrpname = ChannelGroup::GetChannelGroupName(m_changrpid);
+    
+    if (m_changroupname)
+        m_changroupname->SetText(changrpname);    
 
     gContext->addListener(this);
 
@@ -490 +497 @@
         else if (action == "TOGGLERECORD")
             quickRecord();
         else if (action == "TOGGLEFAV")
-            toggleChannelFavorite();
+        {
+            if (m_changrpid == -1)
+                ChannelGroupMenu(0); 
+            else
+                toggleChannelFavorite();
+        }
         else if (action == "CHANUPDATE")
             channelUpdate();
         else if (action == "VOLUMEUP")
@@ -540 +552 @@
 
         menuPopup->AddButton(tr("Reverse Channel Order"));
 
-        if (m_showFavorites)
-            menuPopup->AddButton(tr("Show All Channels"));
-        else
-            menuPopup->AddButton(tr("Show Favourite Channels"));
+        menuPopup->AddButton(tr("Choose Channel Group"));
 
         menuPopup->AddButton(tr("Cancel"));
 
@@ -728 +737 @@
     m_channelInfoIdx.clear();
     m_currentStartChannel = 0;
 
-    DBChanList channels = ChannelUtil::GetChannels(0, true);
+    DBChanList channels = ChannelUtil::GetChannels(0, true, "", m_changrpid);
     ChannelUtil::SortChannels(channels, m_channelOrdering, false);
 
-    if (m_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;
-    }
-
     typedef vector<uint> uint_list_t;
     QMap<QString,uint_list_t> channum_to_index_map;
     QMap<QString,uint_list_t> callsign_to_index_map;
@@ -1268 +1264 @@
             }
             else if (resulttext == tr("Toggle Favourite Channel"))
             {
-                toggleChannelFavorite();
+                if (m_changrpid == -1)
+                    ChannelGroupMenu(0); 
+                else
+                    toggleChannelFavorite();
             }
-            else if (resulttext == tr("Show All Channels"))
+            else if (resulttext == tr("Choose Channel Group"))
             {
-                m_showFavorites = false;
-                generateListings();
-                updateChannels();
+                ChannelGroupMenu(1);
             }
-            else if (resulttext == tr("Show Favourite Channels"))
+        }
+    else if (resultid == "channelgrouptogglemenu")
+        {
+            if (resulttext != tr("Cancel"))
             {
-                m_showFavorites = true;
-                generateListings();
-                updateChannels();
+                int changroupid;
+                changroupid = ChannelGroup::GetChannelGroupId(resulttext);
+               
+                if (changroupid > 0)
+                    toggleChannelFavorite(changroupid);
+            }
+        }
+    else if (resultid == "channelgroupmenu")
+        {
+            if (resulttext != tr("Cancel"))
+            {
+                int changroupid;
+                changroupid = ChannelGroup::GetChannelGroupId(resulttext);
+             
+                if (changroupid > 0)
+                {
+                    m_changrpid = changroupid;
+                    generateListings();
+                    updateChannels();
+
+                    QString changrpname;
+                    changrpname = ChannelGroup::GetChannelGroupName(m_changrpid);
+    
+                    if (m_changroupname)
+                        m_changroupname->SetText(changrpname);
+                }
             }
         }
     }
@@ -1346 +1369 @@
                 m_channelList, chinfo->GetFormatted(m_channelFormat));
 
         QString state = "";
-
-        if (chinfo->favorite > 0)
-        {
-            if (unavailable)
-                state = "favunavailable";
-            else
-                state = "favourite";
-        }
-        else if (unavailable)
-            state = "unavailable";
-
         item->SetText(chinfo->GetFormatted(m_channelFormat), "buttontext", state);
 
         if (showChannelIcon && !chinfo->icon.isEmpty())
@@ -1431 +1443 @@
 
 void GuideGrid::toggleGuideListing()
 {
-    m_showFavorites = (!m_showFavorites);
-    generateListings();
+    int oldchangrpid = m_changrpid;
+    
+    m_changrpid = ChannelGroup::GetNextChannelGroup(m_changrplist, oldchangrpid);
+    
+    if (oldchangrpid != m_changrpid)
+      generateListings();
+
     updateChannels();
+    
+    QString changrpname = ChannelGroup::GetChannelGroupName(m_changrpid);
+    
+    if (m_changroupname)
+        m_changroupname->SetText(changrpname);
 }
 
 void GuideGrid::generateListings()
@@ -1450 +1472 @@
     fillProgramInfos();
 }
 
-void GuideGrid::toggleChannelFavorite()
+void GuideGrid::ChannelGroupMenu(int mode)
+{
+    if (m_changrplist.empty())
+    {
+      QString message = tr("You don't have any channel groups defined");
+
+      MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
+
+      MythConfirmationDialog *okPopup = new MythConfirmationDialog(popupStack,
+                                                                   message, false);
+      if (okPopup->Create())
+          popupStack->AddScreen(okPopup);
+      else
+          delete okPopup;
+
+      return;
+    }
+
+    QString label = tr("Select Channel Group");
+
+    MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
+    MythDialogBox *menuPopup = new MythDialogBox(label, popupStack, "menuPopup");
+
+    if (menuPopup->Create())
+    {
+        if (mode == 0)
+            menuPopup->SetReturnEvent(this, "channelgrouptogglemenu");
+        else
+            menuPopup->SetReturnEvent(this, "channelgroupmenu");           
+
+        for (uint i = 0; i < m_changrplist.size(); i++)
+            menuPopup->AddButton(m_changrplist[i].name);
+
+        menuPopup->AddButton(tr("Cancel"));
+
+        popupStack->AddScreen(menuPopup);
+    }
+    else
+    {
+        delete menuPopup;
+    }
+}
+
+void GuideGrid::toggleChannelFavorite(int grpid)
 {
     MSqlQuery query(MSqlQuery::InitCon());
+    
+    if (grpid == -1)
+    {
+      if (m_changrpid == -1)
+          return;
+      else 
+          grpid = m_changrpid;
+    }
 
     // Get current channel id, and make sure it exists...
     int chanNum = m_currentRow + m_currentStartChannel;
@@ -1464 +1537 @@
         chanNum = 0;
 
     PixmapChannel *ch = GetChannelInfo(chanNum);
-    uint favid  = ch->favorite;
     uint chanid = ch->chanid;
 
-    if (favid > 0) 
-    {
-        query.prepare("DELETE FROM favorites WHERE favid = :FAVID ;");
-        query.bindValue(":FAVID", favid);
-        query.exec(); 
-    }
+    if (m_changrpid == -1)
+        // If currently viewing all channels, allow to add only not delete
+        ChannelGroup::ToggleChannel(chanid, grpid, false);
     else
+        // Only allow delete if viewing the favorite group in question
+        ChannelGroup::ToggleChannel(chanid, grpid, true);
+      
+    // If viewing favorites, refresh because a channel was removed
+    if (m_changrpid != -1)
     {
-        // We have no favorites record...Add one to toggle...
-        query.prepare("INSERT INTO favorites (chanid) VALUES (:FAVID);");
-        query.bindValue(":FAVID", chanid);
-        query.exec(); 
-    }
-
-    if (m_showFavorites)
         generateListings();
-    else
-    {
-        int maxchannel = 0;
-        m_channelCount = m_guideGrid->getChannelCount();
-        fillChannelInfos(false);
-        maxchannel = max((int)GetChannelCount() - 1, 0);
-        m_channelCount = min(m_channelCount, maxchannel + 1);
         updateChannels();
     }
 }

programs/mythfrontend/guidegrid.h

@@ -19 +19 @@
 #include "mythscreentype.h"
 #include "programinfo.h"
 #include "programlist.h"
+#include "channelgroup.h"
 #include "channelutil.h"
 
 using namespace std;
@@ -86 +87 @@
     static void RunProgramGuide(uint           startChanId,
                                 const QString &startChanNum,
                                 TV            *player = NULL,
-                                bool           allowFinder = true);
+                                bool           allowFinder = true,
+                                int            changrpid = -1);
 
     DBChanList GetSelection(void) const;
 
@@ -117 +119 @@
     void pageDown();
     void pageUp();
     void toggleGuideListing();
-    void toggleChannelFavorite();
+    void toggleChannelFavorite(int grpid = -1);
+    void ChannelGroupMenu(int mode = 0);
     void generateListings();
 
     void enter();
@@ -141 +144 @@
   protected:
       GuideGrid(MythScreenStack *parentStack,
               uint chanid = 0, QString channum = "",
-              TV *player = NULL, bool allowFinder = true);
+              TV *player = NULL, bool allowFinder = true,
+              int changrpid=-1);
    ~GuideGrid();
 
   private slots:
@@ -195 +199 @@
     int m_currentRow;
     int m_currentCol;
 
-    bool    m_showFavorites;
     bool    m_sortReverse;
     QString m_channelFormat;
 
@@ -221 +224 @@
 
     QTimer *m_updateTimer;
 
+    int               m_changrpid;
+    ChannelGroupList  m_changrplist;
+
     QMutex            m_jumpToChannelLock;
     JumpToChannel    *m_jumpToChannel;
     bool              m_jumpToChannelEnabled;
@@ -230 +236 @@
     MythUIGuideGrid  *m_guideGrid;
     MythUIText       *m_dateText;
     MythUIText       *m_jumpToText;
+    MythUIText       *m_changroupname;
     MythUIImage      *m_channelImage;
 };
 

programs/mythfrontend/main.cpp

@@ -51 +51 @@
 #include "lcddevice.h"
 #include "langsettings.h"
 #include "mythcommandlineparser.h"
+#include "channelgroupsettings.h"
 
 #include "myththemedmenu.h"
 #include "myththemebase.h"
@@ -523 +524 @@
         EPGSettings settings;
         settings.exec();
     }
+    else if (sel == "settings channelgroups")
+    {
+        ChannelGroupEditor editor;
+        editor.exec();
+    } 
     else if (sel == "settings generalrecpriorities")
     {
         GeneralRecPrioritiesSettings settings;

themes/classic/tv_settings.xml

@@ -99 +99 @@
     </button>
 
     <button>
+      <type>TV_SETTINGS_CHANNEL_GROUP</type>
+      <text>Channel Groups</text>
+      <action>SETTINGS CHANNELGROUPS</action>
+    </button>
+
+    <button>
         <type>TV_SETTINGS_RECORDING_PROFILES</type>
         <text>Recording Profiles</text>
         <text lang="IT">Registrazione</text>

themes/defaultmenu/tv_settings.xml

@@ -123 +123 @@
     </button>
 
     <button>
+      <type>TV_SETTINGS_CHANNEL_GROUP</type>
+      <text>Channel Groups</text>
+      <action>SETTINGS CHANNELGROUPS</action>
+    </button>
+
+    <button>
         <type>TV_SETTINGS_RECORDING_PROFILES</type>
         <text>Recording Profiles</text>
         <text lang="IT">Registrazioni</text>

themes/default-wide/schedule-ui.xml

@@ -37 +37 @@
             <cornerradius>15</cornerradius>
         </shape>
 
+        <textarea name="channelgroup" from="basetextarea">
+            <area>25,245,190,25</area>
+            <align>allcenter</align>
+        </textarea>
+
         <textarea name="datetext" from="basetextarea">
-            <area>25,255,190,25</area>
+            <area>25,265,190,25</area>
             <align>allcenter</align>
         </textarea>
 
@@ -255 +260 @@
         </imagetype>
         
         <textarea name="datetext" from="basetextarea">
-            <area>25,255,190,25</area>
+            <area>25,265,190,25</area>
+            <align>allcenter</align>
+        </textarea>
+
+        <textarea name="channelgroup" from="basetextarea">
+            <area>25,245,190,25</area>
             <align>allcenter</align>
         </textarea>
 

themes/DVR/tv_settings.xml

@@ -99 +99 @@
     </button>
 
     <button>
+      <type>TV_SETTINGS_CHANNEL_GROUP</type>
+      <text>Channel Groups</text>
+      <action>SETTINGS CHANNELGROUPS</action>
+    </button>
+
+    <button>
         <type>TV_SETTINGS_RECORDING_PROFILES</type>
         <text>Recording Profiles</text>
         <text lang="IT">Registrazione</text>