Ticket #3008: mythvideo_grouping_v2.patch

File mythvideo_grouping_v2.patch, 15.0 KB (added by jjkroll@…, 12 years ago)

Update of the patch against svn version 14309.

  • 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

     
    145145
    146146HostCheckBox *VideoDBFolderView()
    147147{
    148     HostCheckBox *hcb = new HostCheckBox("mythvideo.db_folder_view");
    149     hcb->setLabel(QObject::tr("Show folders for database views"));
     148    HostCheckBox *hcb = new HostCheckBox("mythvideo.db_group_view");
     149    hcb->setLabel(QObject::tr("Show groups for database view"));
    150150    hcb->setValue(true);
    151     hcb->setHelpText(QObject::tr("If set, sub folders of your video "
    152                                  "directory will be shown in supported "
    153                                  "views."));
     151    hcb->setHelpText(QObject::tr("If set, the group type is defined below."));
    154152    return hcb;
    155153}
    156154
     155
     156HostComboBox *VideoTreeGroup()
     157{
     158    HostComboBox *gc = new HostComboBox("mythvideo.db_group_type");
     159    gc->setLabel(QObject::tr("Group based on"));
     160    gc->addSelection(QObject::tr("Folder"),"0");
     161    gc->addSelection(QObject::tr("Genres"),"1");
     162    gc->addSelection(QObject::tr("Category"),"2");
     163    gc->setHelpText(QObject::tr("Group videos in the tree"));
     164    return gc;
     165}
     166
     167
    157168HostSpinBox *VideoImageCacheSize()
    158169{
    159170    HostSpinBox *hsb = new HostSpinBox("mythvideo.ImageCacheSize", 10,
     
    576587    general2->addChild(VideoSortIgnoresCase());
    577588    general2->addChild(VideoDBFolderView());
    578589    general2->addChild(VideoTreeRemeber());
     590    general2->addChild(VideoTreeGroup());
    579591    general2->addChild(VideoImageCacheSize());
    580592    addChild(general2);
    581593
  • videotree.cpp

     
    223223            gContext->GetNumSetting("VideoDefaultParentalLevel", 1);
    224224
    225225    file_browser = gContext->GetNumSetting("VideoTreeNoDB", 0);
    226     m_db_folders = gContext->GetNumSetting("mythvideo.db_folder_view", 1);
     226    m_db_group = gContext->GetNumSetting("mythvideo.db_group_view", 1);
     227    m_db_group_type = gContext->GetNumSetting("mythvideo.db_group_type", 0);
    227228
    228229    // Theme and tree stuff
    229230    m_imp->wireUpTheme(this);
     
    363364
    364365void VideoTree::buildVideoList()
    365366{
    366     video_tree_root = m_video_list->buildVideoList(file_browser, !m_db_folders,
     367    video_tree_root = m_video_list->buildVideoList(file_browser, m_db_group,
     368                                                   m_db_group_type,
    367369                                                   current_parental_level,
    368370                                                   false);
    369371    GenericTree *video_tree_data = 0;
     
    462464                             SLOT(slotVideoBrowser()));
    463465            popup->addButton(tr("Switch to Gallery View"), this,
    464466                             SLOT(slotVideoGallery()));
     467
     468            if (m_db_group)
     469            {
     470               if (m_db_group_type != 0)
     471                   popup->addButton(tr("Switch to Folder Grouping"), this,
     472                             SLOT(slotVideoFolderGroup()));
     473
     474               if (m_db_group_type != 1)
     475                   popup->addButton(tr("Switch to Genre Grouping"), this,
     476                             SLOT(slotVideoGenreGroup()));
     477
     478               if (m_db_group_type != 2)
     479                   popup->addButton(tr("Switch to Category Grouping"), this,
     480                             SLOT(slotVideoCategoryGroup()));
     481           }
    465482        }
    466483
    467484        popup->addButton(tr("Cancel"), this, SLOT(slotDoCancel()));
     
    482499    jumpTo(JUMP_VIDEO_GALLERY);
    483500}
    484501
     502void VideoTree::slotVideoFolderGroup()
     503{
     504    cancelPopup();
     505
     506    m_db_group_type = 0;
     507    buildVideoList();
     508}
     509
     510void VideoTree::slotVideoGenreGroup()
     511{
     512    cancelPopup();
     513
     514    m_db_group_type = 1;
     515    buildVideoList();
     516}
     517
     518void VideoTree::slotVideoCategoryGroup()
     519{
     520    cancelPopup();
     521
     522    m_db_group_type = 2;
     523    buildVideoList();
     524}
     525
    485526void VideoTree::slotDoCancel(void)
    486527{
    487528    if (!expectingPopup)
  • videodlg.cpp

     
    229229
    230230void VideoDialog::fetchVideos()
    231231{
    232     video_tree_root = m_video_list->buildVideoList(isFileBrowser, isFlatList,
     232    video_tree_root = m_video_list->buildVideoList(isFileBrowser, isFlatList, 0,
    233233                                                   currentParentalLevel, true);
    234234}
    235235
  • videomanager.cpp

     
    409409    }
    410410    else
    411411    {
    412         m_video_list->refreshList(false, 0, true);
     412        m_video_list->refreshList(false, 0, false, 0);
    413413        m_list_behave->setItemCount(m_video_list->count());
    414414    }
    415415    curitem = m_video_list->getVideoListMetadata(m_list_behave->getIndex());
  • videolist.cpp

     
    440440    typedef std::vector<Metadata *> metadata_view_list;
    441441
    442442  private:
    443     enum metadata_list_type { ltNone, ltFileSystem, ltDBMetadata };
     443    enum metadata_list_type { ltNone, ltFileSystem, ltDBMetadata,
     444                              ltDBGenreGroup, ltDBCategoryGroup };
    444445    typedef MetadataListManager::metadata_list metadata_list;
    445446    typedef MetadataListManager::MetadataPtr MetadataPtr;
    446447
     
    449450
    450451    void build_generic_tree(GenericTree *dst, meta_dir_node *src,
    451452                            bool include_updirs);
    452     GenericTree *buildVideoList(bool filebrowser, bool flatlist,
     453    GenericTree *buildVideoList(bool filebrowser, bool grouplist, int group_type,
    453454                                int parental_level, bool include_updirs);
    454455
    455     void refreshList(bool filebrowser, int parental_level, bool flat_list);
     456    void refreshList(bool filebrowser, int parental_level, bool group_list,
     457                     int group_type);
    456458    void resortList(bool flat_list);
    457459
    458460    Metadata *getVideoListMetadata(int index);
     
    521523    void fillMetadata(metadata_list_type whence);
    522524
    523525    void buildFsysList();
     526    void buildGroupList(metadata_list_type whence);
    524527    void buildDbList();
    525528    void buildFileList(smart_dir_node &directory, metadata_list &metalist,
    526529                       const QString &prefix);
     
    565568    delete m_imp;
    566569}
    567570
    568 GenericTree *VideoList::buildVideoList(bool filebrowser, bool flatlist,
    569     int parental_level, bool include_updirs)
     571GenericTree *VideoList::buildVideoList(bool filebrowser, bool grouplist,
     572    int group_type, int parental_level, bool include_updirs)
    570573{
    571     return m_imp->buildVideoList(filebrowser, flatlist, parental_level,
    572                                  include_updirs);
     574    return m_imp->buildVideoList(filebrowser, grouplist, group_type,
     575                                 parental_level, include_updirs);
    573576}
    574577
    575578void VideoList::refreshList(bool filebrowser, int parental_level,
    576                             bool flat_list)
     579                            bool group_list, int group_type)
    577580{
    578     m_imp->refreshList(filebrowser, parental_level, flat_list);
     581    m_imp->refreshList(filebrowser, parental_level, group_list, group_type);
    579582}
    580583
    581584void VideoList::resortList(bool flat_list)
     
    682685//      basic info is provided.
    683686//      If false, only video information already present in the database is
    684687//      presented.
    685 //   flatlist:
    686 //      If true, the tree is reduced to a single level containing all the
    687 //      videos found.
    688 //      If false, the hierarchy present on the filesystem or in the database
    689 //      is preserved. In this mode, both sub-dirs and updirs are present.
    690 GenericTree *VideoListImp::buildVideoList(bool filebrowser, bool flatlist,
     688//   grouplist:
     689//      If true,
     690//         the tree is built depending on the type of the grouping type desired.
     691//      If false,
     692//        the tree is reduced to a single level containing all the videos found.
     693//   group_type:
     694//       0 - the hierarchy present on the filesystem or in the database
     695//           is preserved. In this mode, both sub-dirs and updirs are present.
     696//       1 - the tree is built based on the genre of the video.
     697//       2 - the tree is built based on the category of the video.
     698GenericTree *VideoListImp::buildVideoList(bool filebrowser, bool grouplist,
     699                                          int group_type,
    691700                                          int parental_level,
    692701                                          bool include_updirs)
    693702{
    694     refreshList(filebrowser, parental_level, flatlist);
     703    refreshList(filebrowser, parental_level, grouplist, group_type);
    695704
    696705    typedef std::map<QString, GenericTree *> string_to_tree;
    697706    string_to_tree prefix_tree_map;
     
    714723}
    715724
    716725void VideoListImp::refreshList(bool filebrowser, int parental_level,
    717                                bool flat_list)
     726                               bool group_list, int group_type)
    718727{
     728    bool flat_list = false;
     729
    719730    m_video_filter.setParentalLevel(parental_level);
    720731
    721     fillMetadata(filebrowser ? ltFileSystem : ltDBMetadata);
     732    if (filebrowser)
     733    {
     734        fillMetadata(ltFileSystem);
     735    }
     736    else
     737    {
     738        if (group_list)
     739        {
     740            switch (group_type)
     741            {
     742                case 0:
     743                {
     744                    fillMetadata(ltDBMetadata);
     745                    VERBOSE(VB_IMPORTANT,QString("Using Folder mode"));
     746                    break;
     747                }
     748                case 1:
     749                {
     750                    fillMetadata(ltDBGenreGroup);
     751                    VERBOSE(VB_IMPORTANT,QString("Using Group mode"));
     752                    break;
     753                }
     754                case 2:
     755                {
     756                    fillMetadata(ltDBCategoryGroup);
     757                    VERBOSE(VB_IMPORTANT,QString("Using Category mode"));
     758                    break;
     759                }
     760            }
     761        }
     762        else
     763        {
     764            fillMetadata(ltDBMetadata);
     765            flat_list = true;
     766        }
     767    }
    722768
    723769    update_meta_view(flat_list);
     770
    724771}
    725772
    726773void VideoListImp::resortList(bool flat_list)
     
    781828        m_metadata.setList(ml);
    782829        m_metadata_tree.clear();
    783830
    784         if (whence == ltFileSystem)
     831        switch (whence)
    785832        {
    786             buildFsysList();
     833            case ltFileSystem:
     834                buildFsysList();
     835                break;
     836            case ltDBMetadata:
     837                buildDbList();
     838                break;
     839            case ltDBGenreGroup:
     840            case ltDBCategoryGroup:
     841                buildGroupList(whence);
     842                break;
     843            case ltNone:
     844                break;
    787845        }
    788         else
     846    }
     847}
     848
     849
     850
     851
     852void VideoListImp::buildGroupList(metadata_list_type whence)
     853{
     854    metadata_list ml;
     855    MetadataListManager::loadAllFromDatabase(ml);
     856    m_metadata.setList(ml);
     857
     858    metadata_view_list mlist;
     859    mlist.reserve(m_metadata.getList().size());
     860
     861    std::back_insert_iterator<metadata_view_list> mli(mlist);
     862    std::transform(m_metadata.getList().begin(), m_metadata.getList().end(),
     863                   mli, to_metadata_ptr());
     864
     865    metadata_path_sort mps(m_sort_ignores_case);
     866    std::sort(mlist.begin(), mlist.end(), mps);
     867
     868    typedef std::map<QString, meta_dir_node *> group_to_node_map;
     869    group_to_node_map gtnm;
     870
     871    meta_dir_node *video_root = &m_metadata_tree;
     872
     873    smart_dir_node sdn = video_root->addSubDir("All");
     874    meta_dir_node* all_group_node = sdn.get();
     875
     876    for (metadata_view_list::iterator p = mlist.begin(); p != mlist.end(); ++p)
     877    {
     878        Metadata *data = *p;
     879
     880        all_group_node->addEntry(smart_meta_node(new meta_data_node(data)));
     881
     882        std::vector <QString> groups;
     883
     884        switch (whence)
    789885        {
    790             buildDbList();
     886            case ltDBGenreGroup:
     887            {
     888                std::vector <std::pair <int, QString> > genres = data->Genres();
     889
     890                for (std::vector <std::pair <int, QString> >::iterator i =
     891                                         genres.begin(); i != genres.end(); i++)
     892                {
     893                    std::pair <int, QString> item = *i;
     894                    groups.push_back(item.second);
     895                }
     896                break;
     897            }
     898            case ltDBCategoryGroup:
     899            {
     900                groups.push_back(data->Category());
     901                break;
     902            }
     903            default:
     904            {
     905                VERBOSE(VB_IMPORTANT,
     906                    QString("Invalid type of grouping"));
     907                break;
     908            }
    791909        }
     910
     911        if (groups.size() == 0)
     912        {
     913            meta_dir_node *group_node = gtnm["Unknown"];
     914
     915            if (group_node == NULL)
     916            {
     917                smart_dir_node sdn = video_root->addSubDir("Unknown");
     918                group_node = sdn.get();
     919                gtnm["Unknown"] = group_node;
     920            }
     921
     922            group_node->addEntry(smart_meta_node(new meta_data_node(data)));
     923        }
     924
     925        for (std::vector <QString>::iterator i = groups.begin();
     926                                                         i != groups.end(); i++)
     927        {
     928            QString item = *i;
     929
     930            meta_dir_node *group_node = gtnm[item];
     931
     932            if (group_node == NULL)
     933            {
     934                smart_dir_node sdn = video_root->addSubDir(item);
     935                group_node = sdn.get();
     936                gtnm[item] = group_node;
     937            }
     938
     939            group_node->addEntry(smart_meta_node(new meta_data_node(data)));
     940        }
    792941    }
    793942}
    794943
     944
    795945void VideoListImp::buildDbList()
    796946{
    797947    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;