Ticket #3008: mythvideo_grouping.patch

File mythvideo_grouping.patch, 15.2 KB (added by pasha@…, 13 years ago)

Patch to add genre and category grouping to MythVideo? tree view

  • videolist.h

     
    2525    VideoList();
    2626    ~VideoList();
    2727
    28     GenericTree *buildVideoList(bool filebrowser, bool flatlist,
     28    GenericTree *buildVideoList(bool filebrowser, bool group_list, int group_type,
    2929                                int parental_level, bool include_updirs);
    3030
    31     void refreshList(bool filebrowser, int parental_level, bool flatlist);
     31    void refreshList(bool filebrowser, int parental_level, bool grouplist,
     32                     int group_type);
    3233
    3334    // If the only change to the underlying metadata requires
    3435    // another sort (for video manager currently).
  • globalsettings.cpp

     
    141141
    142142HostCheckBox *VideoDBFolderView()
    143143{
    144     HostCheckBox *hcb = new HostCheckBox("mythvideo.db_folder_view");
    145     hcb->setLabel(QObject::tr("Show folders for database views"));
     144    HostCheckBox *hcb = new HostCheckBox("mythvideo.db_group_view");
     145    hcb->setLabel(QObject::tr("Show groups for database view"));
    146146    hcb->setValue(true);
    147     hcb->setHelpText(QObject::tr("If set, sub folders of your video "
    148                                  "directory will be shown in supported "
    149                                  "views."));
     147    hcb->setHelpText(QObject::tr("If set, the group type is defined below."));
    150148    return hcb;
    151149}
    152150
     151
     152HostComboBox *VideoTreeGroup()
     153{
     154    HostComboBox *gc = new HostComboBox("mythvideo.db_group_type");
     155    gc->setLabel(QObject::tr("Group based on"));
     156    gc->addSelection(QObject::tr("Folder"),"0");
     157    gc->addSelection(QObject::tr("Genres"),"1");
     158    gc->addSelection(QObject::tr("Category"),"2");
     159    gc->setHelpText(QObject::tr("Group videos in the tree"));
     160    return gc;
     161}
     162
     163
    153164HostSpinBox *VideoImageCacheSize()
    154165{
    155166    HostSpinBox *hsb = new HostSpinBox("mythvideo.ImageCacheSize", 10,
     
    550561    general2->addChild(VideoNewBrowsable());
    551562    general2->addChild(VideoSortIgnoresCase());
    552563    general2->addChild(VideoDBFolderView());
     564    general2->addChild(VideoTreeGroup());
    553565    general2->addChild(VideoImageCacheSize());
    554566    addChild(general2);
    555567
  • videotree.cpp

     
    219219            gContext->GetNumSetting("VideoDefaultParentalLevel", 1);
    220220
    221221    file_browser = gContext->GetNumSetting("VideoTreeNoDB", 0);
    222     m_db_folders = gContext->GetNumSetting("mythvideo.db_folder_view", 1);
     222    m_db_group = gContext->GetNumSetting("mythvideo.db_group_view", 1);
     223    m_db_group_type = gContext->GetNumSetting("mythvideo.db_group_type", 0);
    223224
    224225    // Theme and tree stuff
    225226    m_imp->wireUpTheme(this);
     
    343344
    344345void VideoTree::buildVideoList()
    345346{
    346     video_tree_root = m_video_list->buildVideoList(file_browser, !m_db_folders,
     347    video_tree_root = m_video_list->buildVideoList(file_browser, m_db_group,
     348                                                   m_db_group_type,
    347349                                                   current_parental_level,
    348350                                                   false);
    349351    GenericTree *video_tree_data = 0;
     
    443445
    444446            tempButton = popup->addButton(tr("Switch to Browse View"), this,
    445447                                          SLOT(slotVideoBrowser()));
    446 
    447448            if (!focusButton)
    448449                focusButton = tempButton;
    449450
    450451            popup->addButton(tr("Switch to Gallery View"), this,
    451452                             SLOT(slotVideoGallery()));
     453
     454            if (m_db_group)
     455            {
     456               if (m_db_group_type != 0)
     457                   popup->addButton(tr("Switch to Folder Grouping"), this,
     458                             SLOT(slotVideoFolderGroup()));
     459
     460               if (m_db_group_type != 1)
     461                   popup->addButton(tr("Switch to Genre Grouping"), this,
     462                             SLOT(slotVideoGenreGroup()));
     463
     464               if (m_db_group_type != 2)
     465                   popup->addButton(tr("Switch to Category Grouping"), this,
     466                             SLOT(slotVideoCategoryGroup()));
     467           }
    452468        }
    453469
    454470        popup->addButton(tr("Cancel"), this, SLOT(slotDoCancel()));
     
    469485    jumpTo(JUMP_VIDEO_GALLERY);
    470486}
    471487
     488void VideoTree::slotVideoFolderGroup()
     489{
     490    cancelPopup();
     491
     492    m_db_group_type = 0;
     493    buildVideoList();
     494}
     495
     496void VideoTree::slotVideoGenreGroup()
     497{
     498    cancelPopup();
     499
     500    m_db_group_type = 1;
     501    buildVideoList();
     502}
     503
     504void VideoTree::slotVideoCategoryGroup()
     505{
     506    cancelPopup();
     507
     508    m_db_group_type = 2;
     509    buildVideoList();
     510}
     511
    472512void VideoTree::slotDoCancel(void)
    473513{
    474514    if (!expectingPopup)
  • videodlg.cpp

     
    231231
    232232void VideoDialog::fetchVideos()
    233233{
    234     video_tree_root = m_video_list->buildVideoList(isFileBrowser, isFlatList,
     234    video_tree_root = m_video_list->buildVideoList(isFileBrowser, isFlatList, 0,
    235235                                                   currentParentalLevel, true);
    236236}
    237237
  • videomanager.cpp

     
    403403    }
    404404    else
    405405    {
    406         m_video_list->refreshList(false, 0, true);
     406        m_video_list->refreshList(false, 0, false, 0);
    407407        m_list_behave->setItemCount(m_video_list->count());
    408408    }
    409409    curitem = m_video_list->getVideoListMetadata(m_list_behave->getIndex());
  • videolist.cpp

     
    416416    typedef std::vector<Metadata *> metadata_view_list;
    417417
    418418  private:
    419     enum metadata_list_type { ltNone, ltFileSystem, ltDBMetadata };
     419    enum metadata_list_type { ltNone, ltFileSystem, ltDBMetadata,
     420                              ltDBGenreGroup, ltDBCategoryGroup };
    420421    typedef MetadataListManager::metadata_list metadata_list;
    421422    typedef MetadataListManager::MetadataPtr MetadataPtr;
    422423
     
    425426
    426427    void build_generic_tree(GenericTree *dst, meta_dir_node *src,
    427428                            bool include_updirs);
    428     GenericTree *buildVideoList(bool filebrowser, bool flatlist,
     429    GenericTree *buildVideoList(bool filebrowser, bool grouplist, int group_type,
    429430                                int parental_level, bool include_updirs);
    430431
    431     void refreshList(bool filebrowser, int parental_level, bool flat_list);
     432    void refreshList(bool filebrowser, int parental_level, bool group_list,
     433                     int group_type);
    432434    void resortList(bool flat_list);
    433435
    434436    Metadata *getVideoListMetadata(int index);
     
    497499    void fillMetadata(metadata_list_type whence);
    498500
    499501    void buildFsysList();
     502    void buildGroupList(metadata_list_type whence);
    500503    void buildDbList();
    501504    void buildFileList(smart_dir_node &directory, metadata_list &metalist,
    502505                       const QString &prefix);
     
    541544    delete m_imp;
    542545}
    543546
    544 GenericTree *VideoList::buildVideoList(bool filebrowser, bool flatlist,
    545     int parental_level, bool include_updirs)
     547GenericTree *VideoList::buildVideoList(bool filebrowser, bool grouplist,
     548    int group_type, int parental_level, bool include_updirs)
    546549{
    547     return m_imp->buildVideoList(filebrowser, flatlist, parental_level,
    548                                  include_updirs);
     550    return m_imp->buildVideoList(filebrowser, grouplist, group_type,
     551                                 parental_level, include_updirs);
    549552}
    550553
    551554void VideoList::refreshList(bool filebrowser, int parental_level,
    552                             bool flat_list)
     555                            bool group_list, int group_type)
    553556{
    554     m_imp->refreshList(filebrowser, parental_level, flat_list);
     557    m_imp->refreshList(filebrowser, parental_level, group_list, group_type);
    555558}
    556559
    557560void VideoList::resortList(bool flat_list)
     
    655658//      basic info is provided.
    656659//      If false, only video information already present in the database is
    657660//      presented.
    658 //   flatlist:
    659 //      If true, the tree is reduced to a single level containing all the
    660 //      videos found.
    661 //      If false, the hierarchy present on the filesystem or in the database
    662 //      is preserved. In this mode, both sub-dirs and updirs are present.
    663 GenericTree *VideoListImp::buildVideoList(bool filebrowser, bool flatlist,
     661//   grouplist:
     662//      If true,
     663//         the tree is built depending on the type of the grouping type desired.
     664//      If false,
     665//        the tree is reduced to a single level containing all the videos found.
     666//   group_type:
     667//       0 - the hierarchy present on the filesystem or in the database
     668//           is preserved. In this mode, both sub-dirs and updirs are present.
     669//       1 - the tree is built based on the genre of the video.
     670//       2 - the tree is built based on the category of the video.
     671GenericTree *VideoListImp::buildVideoList(bool filebrowser, bool grouplist,
     672                                          int group_type,
    664673                                          int parental_level,
    665674                                          bool include_updirs)
    666675{
    667     refreshList(filebrowser, parental_level, flatlist);
     676    refreshList(filebrowser, parental_level, grouplist, group_type);
    668677
    669678    typedef std::map<QString, GenericTree *> string_to_tree;
    670679    string_to_tree prefix_tree_map;
     
    687696}
    688697
    689698void VideoListImp::refreshList(bool filebrowser, int parental_level,
    690                                bool flat_list)
     699                               bool group_list, int group_type)
    691700{
     701    bool flat_list = false;
     702
    692703    m_video_filter.setParentalLevel(parental_level);
    693704
    694     fillMetadata(filebrowser ? ltFileSystem : ltDBMetadata);
     705    if (filebrowser)
     706    {
     707        fillMetadata(ltFileSystem);
     708    }
     709    else
     710    {
     711        if (group_list)
     712        {
     713            switch (group_type)
     714            {
     715                case 0:
     716                {
     717                    fillMetadata(ltDBMetadata);
     718                    VERBOSE(VB_IMPORTANT,QString("Using Folder mode"));
     719                    break;
     720                }
     721                case 1:
     722                {
     723                    fillMetadata(ltDBGenreGroup);
     724                    VERBOSE(VB_IMPORTANT,QString("Using Group mode"));
     725                    break;
     726                }
     727                case 2:
     728                {
     729                    fillMetadata(ltDBCategoryGroup);
     730                    VERBOSE(VB_IMPORTANT,QString("Using Category mode"));
     731                    break;
     732                }
     733            }
     734        }
     735        else
     736        {
     737            fillMetadata(ltDBMetadata);
     738            flat_list = true;
     739        }
     740    }
    695741
    696742    update_meta_view(flat_list);
     743
    697744}
    698745
    699746void VideoListImp::resortList(bool flat_list)
     
    753800        m_metadata.setList(ml);
    754801        m_metadata_tree.clear();
    755802
    756         if (whence == ltFileSystem)
     803        switch (whence)
    757804        {
    758             buildFsysList();
     805            case ltFileSystem:
     806                buildFsysList();
     807                break;
     808            case ltDBMetadata:
     809                buildDbList();
     810                break;
     811            case ltDBGenreGroup:
     812            case ltDBCategoryGroup:
     813                buildGroupList(whence);
     814                break;
     815            case ltNone:
     816                break;
    759817        }
    760         else
     818    }
     819}
     820
     821
     822
     823
     824void VideoListImp::buildGroupList(metadata_list_type whence)
     825{
     826    metadata_list ml;
     827    MetadataListManager::loadAllFromDatabase(ml);
     828    m_metadata.setList(ml);
     829
     830    metadata_view_list mlist;
     831    mlist.reserve(m_metadata.getList().size());
     832
     833    std::back_insert_iterator<metadata_view_list> mli(mlist);
     834    std::transform(m_metadata.getList().begin(), m_metadata.getList().end(),
     835                   mli, to_metadata_ptr());
     836
     837    metadata_path_sort mps(m_sort_ignores_case);
     838    std::sort(mlist.begin(), mlist.end(), mps);
     839
     840    typedef std::map<QString, meta_dir_node *> group_to_node_map;
     841    group_to_node_map gtnm;
     842
     843    meta_dir_node *video_root = &m_metadata_tree;
     844
     845    smart_dir_node sdn = video_root->addSubDir("All");
     846    meta_dir_node* all_group_node = sdn.get();
     847
     848    for (metadata_view_list::iterator p = mlist.begin(); p != mlist.end(); ++p)
     849    {
     850        Metadata *data = *p;
     851
     852        all_group_node->addEntry(smart_meta_node(new meta_data_node(data)));
     853
     854        std::vector <QString> groups;
     855
     856        switch (whence)
    761857        {
    762             buildDbList();
     858            case ltDBGenreGroup:
     859            {
     860                std::vector <std::pair <int, QString> > genres = data->Genres();
     861
     862                for (std::vector <std::pair <int, QString> >::iterator i =
     863                                         genres.begin(); i != genres.end(); i++)
     864                {
     865                    std::pair <int, QString> item = *i;
     866                    groups.push_back(item.second);
     867                }
     868                break;
     869            }
     870            case ltDBCategoryGroup:
     871            {
     872                groups.push_back(data->Category());
     873                break;
     874            }
     875            default:
     876            {
     877                VERBOSE(VB_IMPORTANT,
     878                    QString("Invalid type of grouping"));
     879                break;
     880            }
    763881        }
     882
     883        if (groups.size() == 0)
     884        {
     885            meta_dir_node *group_node = gtnm["Unknown"];
     886
     887            if (group_node == NULL)
     888            {
     889                smart_dir_node sdn = video_root->addSubDir("Unknown");
     890                group_node = sdn.get();
     891                gtnm["Unknown"] = group_node;
     892            }
     893
     894            group_node->addEntry(smart_meta_node(new meta_data_node(data)));
     895        }
     896
     897        for (std::vector <QString>::iterator i = groups.begin();
     898                                                         i != groups.end(); i++)
     899        {
     900            QString item = *i;
     901
     902            meta_dir_node *group_node = gtnm[item];
     903
     904            if (group_node == NULL)
     905            {
     906                smart_dir_node sdn = video_root->addSubDir(item);
     907                group_node = sdn.get();
     908                gtnm[item] = group_node;
     909            }
     910
     911            group_node->addEntry(smart_meta_node(new meta_data_node(data)));
     912        }
    764913    }
    765914}
    766915
     916
    767917void VideoListImp::buildDbList()
    768918{
    769919    metadata_list ml;
  • videotree.h

     
    3131    void slotViewPlot();
    3232    void slotDoFilter();
    3333    void slotWatchVideo();
     34    void slotVideoFolderGroup();
     35    void slotVideoGenreGroup();
     36    void slotVideoCategoryGroup();
    3437
    3538    void handleTreeListSelection(int node_int);
    3639    void handleTreeListEntry(int node_int);
     
    4952    Metadata *curitem;
    5053    int current_parental_level;
    5154    bool file_browser;
    52     bool m_db_folders;
     55    bool m_db_group;
     56    int m_db_group_type;
    5357
    5458    VideoList    *m_video_list;
    5559    GenericTree *video_tree_root;