Ticket #3008: mythvideo_grouping.patch

videolist.h

@@ -25 +25 @@
     VideoList();
     ~VideoList();
 
-    GenericTree *buildVideoList(bool filebrowser, bool flatlist,
+    GenericTree *buildVideoList(bool filebrowser, bool group_list, int group_type,
                                 int parental_level, bool include_updirs);
 
-    void refreshList(bool filebrowser, int parental_level, bool flatlist);
+    void refreshList(bool filebrowser, int parental_level, bool grouplist, 
+                     int group_type);
 
     // If the only change to the underlying metadata requires
     // another sort (for video manager currently).

globalsettings.cpp

@@ -141 +141 @@
 
 HostCheckBox *VideoDBFolderView()
 {
-    HostCheckBox *hcb = new HostCheckBox("mythvideo.db_folder_view");
-    hcb->setLabel(QObject::tr("Show folders for database views"));
+    HostCheckBox *hcb = new HostCheckBox("mythvideo.db_group_view");
+    hcb->setLabel(QObject::tr("Show groups for database view"));
     hcb->setValue(true);
-    hcb->setHelpText(QObject::tr("If set, sub folders of your video "
-                                 "directory will be shown in supported "
-                                 "views."));
+    hcb->setHelpText(QObject::tr("If set, the group type is defined below."));
     return hcb;
 }
 
+
+HostComboBox *VideoTreeGroup()
+{
+    HostComboBox *gc = new HostComboBox("mythvideo.db_group_type");
+    gc->setLabel(QObject::tr("Group based on"));
+    gc->addSelection(QObject::tr("Folder"),"0");
+    gc->addSelection(QObject::tr("Genres"),"1");
+    gc->addSelection(QObject::tr("Category"),"2");
+    gc->setHelpText(QObject::tr("Group videos in the tree"));
+    return gc;
+}
+
+
 HostSpinBox *VideoImageCacheSize()
 {
     HostSpinBox *hsb = new HostSpinBox("mythvideo.ImageCacheSize", 10,
@@ -550 +561 @@
     general2->addChild(VideoNewBrowsable());
     general2->addChild(VideoSortIgnoresCase());
     general2->addChild(VideoDBFolderView());
+    general2->addChild(VideoTreeGroup());
     general2->addChild(VideoImageCacheSize());
     addChild(general2);
 

videotree.cpp

@@ -219 +219 @@
             gContext->GetNumSetting("VideoDefaultParentalLevel", 1);
 
     file_browser = gContext->GetNumSetting("VideoTreeNoDB", 0);
-    m_db_folders = gContext->GetNumSetting("mythvideo.db_folder_view", 1);
+    m_db_group = gContext->GetNumSetting("mythvideo.db_group_view", 1);
+    m_db_group_type = gContext->GetNumSetting("mythvideo.db_group_type", 0);
 
     // Theme and tree stuff
     m_imp->wireUpTheme(this);
@@ -343 +344 @@
 
 void VideoTree::buildVideoList()
 {
-    video_tree_root = m_video_list->buildVideoList(file_browser, !m_db_folders,
+    video_tree_root = m_video_list->buildVideoList(file_browser, m_db_group, 
+                                                   m_db_group_type,
                                                    current_parental_level,
                                                    false);
     GenericTree *video_tree_data = 0;
@@ -443 +445 @@
 
             tempButton = popup->addButton(tr("Switch to Browse View"), this,
                                           SLOT(slotVideoBrowser()));
-
             if (!focusButton)
                 focusButton = tempButton;
 
             popup->addButton(tr("Switch to Gallery View"), this,
                              SLOT(slotVideoGallery()));
+
+            if (m_db_group)
+            {
+               if (m_db_group_type != 0)
+                   popup->addButton(tr("Switch to Folder Grouping"), this,
+                             SLOT(slotVideoFolderGroup()));
+
+               if (m_db_group_type != 1)
+                   popup->addButton(tr("Switch to Genre Grouping"), this,
+                             SLOT(slotVideoGenreGroup()));
+
+               if (m_db_group_type != 2)
+                   popup->addButton(tr("Switch to Category Grouping"), this,
+                             SLOT(slotVideoCategoryGroup()));
+           }
         }
 
         popup->addButton(tr("Cancel"), this, SLOT(slotDoCancel()));
@@ -469 +485 @@
     jumpTo(JUMP_VIDEO_GALLERY);
 }
 
+void VideoTree::slotVideoFolderGroup()
+{
+    cancelPopup();
+
+    m_db_group_type = 0;
+    buildVideoList();
+}
+
+void VideoTree::slotVideoGenreGroup()
+{
+    cancelPopup();
+
+    m_db_group_type = 1;
+    buildVideoList();
+}
+
+void VideoTree::slotVideoCategoryGroup()
+{
+    cancelPopup();
+
+    m_db_group_type = 2;
+    buildVideoList();
+}
+
 void VideoTree::slotDoCancel(void)
 {
     if (!expectingPopup)

videodlg.cpp

@@ -231 +231 @@
 
 void VideoDialog::fetchVideos()
 {
-    video_tree_root = m_video_list->buildVideoList(isFileBrowser, isFlatList,
+    video_tree_root = m_video_list->buildVideoList(isFileBrowser, isFlatList, 0,
                                                    currentParentalLevel, true);
 }
 

videomanager.cpp

@@ -403 +403 @@
     }
     else
     {
-        m_video_list->refreshList(false, 0, true);
+        m_video_list->refreshList(false, 0, false, 0);
         m_list_behave->setItemCount(m_video_list->count());
     }
     curitem = m_video_list->getVideoListMetadata(m_list_behave->getIndex());

videolist.cpp

@@ -416 +416 @@
     typedef std::vector<Metadata *> metadata_view_list;
 
   private:
-    enum metadata_list_type { ltNone, ltFileSystem, ltDBMetadata };
+    enum metadata_list_type { ltNone, ltFileSystem, ltDBMetadata, 
+                              ltDBGenreGroup, ltDBCategoryGroup };
     typedef MetadataListManager::metadata_list metadata_list;
     typedef MetadataListManager::MetadataPtr MetadataPtr;
 
@@ -425 +426 @@
 
     void build_generic_tree(GenericTree *dst, meta_dir_node *src,
                             bool include_updirs);
-    GenericTree *buildVideoList(bool filebrowser, bool flatlist,
+    GenericTree *buildVideoList(bool filebrowser, bool grouplist, int group_type,
                                 int parental_level, bool include_updirs);
 
-    void refreshList(bool filebrowser, int parental_level, bool flat_list);
+    void refreshList(bool filebrowser, int parental_level, bool group_list, 
+                     int group_type);
     void resortList(bool flat_list);
 
     Metadata *getVideoListMetadata(int index);
@@ -497 +499 @@
     void fillMetadata(metadata_list_type whence);
 
     void buildFsysList();
+    void buildGroupList(metadata_list_type whence);
     void buildDbList();
     void buildFileList(smart_dir_node &directory, metadata_list &metalist,
                        const QString &prefix);
@@ -541 +544 @@
     delete m_imp;
 }
 
-GenericTree *VideoList::buildVideoList(bool filebrowser, bool flatlist,
-    int parental_level, bool include_updirs)
+GenericTree *VideoList::buildVideoList(bool filebrowser, bool grouplist, 
+    int group_type, int parental_level, bool include_updirs)
 {
-    return m_imp->buildVideoList(filebrowser, flatlist, parental_level,
-                                 include_updirs);
+    return m_imp->buildVideoList(filebrowser, grouplist, group_type, 
+                                 parental_level, include_updirs);
 }
 
 void VideoList::refreshList(bool filebrowser, int parental_level,
-                            bool flat_list)
+                            bool group_list, int group_type)
 {
-    m_imp->refreshList(filebrowser, parental_level, flat_list);
+    m_imp->refreshList(filebrowser, parental_level, group_list, group_type);
 }
 
 void VideoList::resortList(bool flat_list)
@@ -655 +658 @@
 //      basic info is provided.
 //      If false, only video information already present in the database is
 //      presented.
-//   flatlist:
-//      If true, the tree is reduced to a single level containing all the
-//      videos found.
-//      If false, the hierarchy present on the filesystem or in the database
-//      is preserved. In this mode, both sub-dirs and updirs are present.
-GenericTree *VideoListImp::buildVideoList(bool filebrowser, bool flatlist,
+//   grouplist:
+//      If true, 
+//         the tree is built depending on the type of the grouping type desired.
+//      If false,
+//        the tree is reduced to a single level containing all the videos found.
+//   group_type:
+//       0 - the hierarchy present on the filesystem or in the database
+//           is preserved. In this mode, both sub-dirs and updirs are present.
+//       1 - the tree is built based on the genre of the video.
+//       2 - the tree is built based on the category of the video.
+GenericTree *VideoListImp::buildVideoList(bool filebrowser, bool grouplist, 
+                                          int group_type,
                                           int parental_level,
                                           bool include_updirs)
 {
-    refreshList(filebrowser, parental_level, flatlist);
+    refreshList(filebrowser, parental_level, grouplist, group_type);
 
     typedef std::map<QString, GenericTree *> string_to_tree;
     string_to_tree prefix_tree_map;
@@ -687 +696 @@
 }
 
 void VideoListImp::refreshList(bool filebrowser, int parental_level,
-                               bool flat_list)
+                               bool group_list, int group_type)
 {
+    bool flat_list = false;
+
     m_video_filter.setParentalLevel(parental_level);
 
-    fillMetadata(filebrowser ? ltFileSystem : ltDBMetadata);
+    if (filebrowser)
+    {
+        fillMetadata(ltFileSystem);
+    }
+    else
+    {
+        if (group_list)
+        {
+            switch (group_type)
+            {
+                case 0:
+                {
+                    fillMetadata(ltDBMetadata);
+                    VERBOSE(VB_IMPORTANT,QString("Using Folder mode"));
+                    break;
+                }
+                case 1:
+                {
+                    fillMetadata(ltDBGenreGroup);
+                    VERBOSE(VB_IMPORTANT,QString("Using Group mode"));
+                    break;
+                }
+                case 2:
+                {
+                    fillMetadata(ltDBCategoryGroup);
+                    VERBOSE(VB_IMPORTANT,QString("Using Category mode"));
+                    break;
+                }
+            }
+        }
+        else
+        {
+            fillMetadata(ltDBMetadata);
+            flat_list = true;
+        }
+    }
 
     update_meta_view(flat_list);
+
 }
 
 void VideoListImp::resortList(bool flat_list)
@@ -753 +800 @@
         m_metadata.setList(ml);
         m_metadata_tree.clear();
 
-        if (whence == ltFileSystem)
+        switch (whence)
         {
-            buildFsysList();
+            case ltFileSystem: 
+                buildFsysList();
+                break;
+            case ltDBMetadata:
+                buildDbList();
+                break;
+            case ltDBGenreGroup:
+            case ltDBCategoryGroup:
+                buildGroupList(whence);
+                break;
+            case ltNone:
+                break; 
         }
-        else
+    }
+}
+
+
+
+
+void VideoListImp::buildGroupList(metadata_list_type whence)
+{
+    metadata_list ml;
+    MetadataListManager::loadAllFromDatabase(ml);
+    m_metadata.setList(ml);
+
+    metadata_view_list mlist;
+    mlist.reserve(m_metadata.getList().size());
+
+    std::back_insert_iterator<metadata_view_list> mli(mlist);
+    std::transform(m_metadata.getList().begin(), m_metadata.getList().end(),
+                   mli, to_metadata_ptr());
+
+    metadata_path_sort mps(m_sort_ignores_case);
+    std::sort(mlist.begin(), mlist.end(), mps);
+
+    typedef std::map<QString, meta_dir_node *> group_to_node_map;
+    group_to_node_map gtnm;
+
+    meta_dir_node *video_root = &m_metadata_tree;
+
+    smart_dir_node sdn = video_root->addSubDir("All");
+    meta_dir_node* all_group_node = sdn.get();
+
+    for (metadata_view_list::iterator p = mlist.begin(); p != mlist.end(); ++p)
+    {
+        Metadata *data = *p;
+
+        all_group_node->addEntry(smart_meta_node(new meta_data_node(data)));
+
+        std::vector <QString> groups;
+
+        switch (whence)
         {
-            buildDbList();
+            case ltDBGenreGroup:
+            {
+                std::vector <std::pair <int, QString> > genres = data->Genres();
+
+                for (std::vector <std::pair <int, QString> >::iterator i = 
+                                         genres.begin(); i != genres.end(); i++)
+                {
+                    std::pair <int, QString> item = *i;
+                    groups.push_back(item.second);
+                }
+                break;
+            }
+            case ltDBCategoryGroup:
+            {
+                groups.push_back(data->Category());
+                break;
+            }
+            default:
+            {
+                VERBOSE(VB_IMPORTANT,
+                    QString("Invalid type of grouping"));
+                break;
+            }
         }
+
+        if (groups.size() == 0)
+        {
+            meta_dir_node *group_node = gtnm["Unknown"];
+
+            if (group_node == NULL)
+            {
+                smart_dir_node sdn = video_root->addSubDir("Unknown");
+                group_node = sdn.get();
+                gtnm["Unknown"] = group_node;
+            }
+
+            group_node->addEntry(smart_meta_node(new meta_data_node(data)));
+        }
+
+        for (std::vector <QString>::iterator i = groups.begin(); 
+                                                         i != groups.end(); i++)
+        {
+            QString item = *i;
+
+            meta_dir_node *group_node = gtnm[item];
+
+            if (group_node == NULL)
+            {
+                smart_dir_node sdn = video_root->addSubDir(item);
+                group_node = sdn.get();
+                gtnm[item] = group_node;
+            }
+
+            group_node->addEntry(smart_meta_node(new meta_data_node(data)));
+        }
     }
 }
 
+
 void VideoListImp::buildDbList()
 {
     metadata_list ml;

videotree.h

@@ -31 +31 @@
     void slotViewPlot();
     void slotDoFilter();
     void slotWatchVideo();
+    void slotVideoFolderGroup();
+    void slotVideoGenreGroup();
+    void slotVideoCategoryGroup();
 
     void handleTreeListSelection(int node_int);
     void handleTreeListEntry(int node_int);
@@ -49 +52 @@
     Metadata *curitem;
     int current_parental_level;
     bool file_browser;
-    bool m_db_folders;
+    bool m_db_group;
+    int m_db_group_type;
 
     VideoList    *m_video_list;
     GenericTree *video_tree_root;