Changeset b782a816f2f6

Show
Ignore:
Timestamp:
11/16/08 14:16:09 (7 weeks ago)
Author:
Milosz Derezynski <monostatic77@…>
Branch:
trunk
Message:

* Change ScanEnd? signal from emitting a bunch of gints to a single struct ScanSummary?, containing detailed data about the currently last finished scan

Files:
6 modified

Legend:

Unmodified
Added
Removed

  • include/mpx/mpx-library-scanner-thread.hh

    r988 r989  
    3737namespace MPX 
    3838{ 
    39    enum ScanResult { 
     39    enum ScanResult { 
    4040        SCAN_RESULT_OK, 
    4141        SCAN_RESULT_ERROR, 
    … …  
    4343        SCAN_RESULT_UPTODATE 
    4444    }; 
    45      
     45 
     46    typedef std::pair<std::string, std::string> SSFileInfo; 
     47 
     48    struct ScanSummary 
     49    { 
     50        gint64  FilesAdded; 
     51        gint64  FilesErroneous; 
     52        gint64  FilesUpToDate; 
     53        gint64  FilesUpdated; 
     54        gint64  FilesTotal; 
     55 
     56        std::vector<SSFileInfo> FileListErroneous; 
     57        std::vector<SSFileInfo> FileListUpdated; 
     58 
     59        ScanSummary () 
     60        : FilesAdded(0) 
     61        , FilesErroneous(0) 
     62        , FilesUpToDate(0) 
     63        , FilesUpdated(0) 
     64        , FilesTotal(0) 
     65        { 
     66        } 
     67    }; 
     68 
    4669    class HAL; 
    4770    class MetadataReaderTagLib; 
    … …  
    5073        public: 
    5174 
    52             typedef sigc::signal<void>                                     SignalScanStart_t ; 
    53             typedef sigc::signal<void, gint64,gint64>                      SignalScanRun_t ; 
    54             typedef sigc::signal<void, gint64,gint64,gint64,gint64,gint64> SignalScanEnd_t ; 
    55             typedef sigc::signal<void>                                     SignalReload_t ; 
    56             typedef sigc::signal<void, gint64>                             SignalNewAlbum_t ; 
    57             typedef sigc::signal<void, gint64>                             SignalNewArtist_t ; 
    58             typedef sigc::signal<void, Track&, gint64, gint64>             SignalNewTrack_t ; 
     75            typedef sigc::signal<void>                              SignalScanStart_t ; 
     76            typedef sigc::signal<void, gint64,gint64>               SignalScanRun_t ; 
     77            typedef sigc::signal<void, ScanSummary const&>          SignalScanEnd_t ; 
     78            typedef sigc::signal<void>                              SignalReload_t ; 
     79            typedef sigc::signal<void, gint64>                      SignalNewAlbum_t ; 
     80            typedef sigc::signal<void, gint64>                      SignalNewArtist_t ; 
     81            typedef sigc::signal<void, Track&, gint64, gint64>      SignalNewTrack_t ; 
    5982 
    6083            typedef sigc::signal<void, 
    … …  
    6386                std::string const&, 
    6487                std::string const&, 
    65                 std::string const&>                                         SignalCacheCover_t ; 
     88                std::string const&>                                 SignalCacheCover_t ; 
    6689             
    6790            typedef sigx::signal_f<SignalScanStart_t>           signal_scan_start_x ; 
    … …  
    173196            gint64                        m_Flags; 
    174197             
    175             gint64                        m_added; 
    176             gint64                        m_erroneous; 
    177             gint64                        m_uptodate; 
    178             gint64                        m_updated; 
    179             gint64                        m_total; 
     198            ScanSummary                   m_ScanSummary; 
    180199        }; 
    181200} 

  • mpx/library-scanner-thread.cc

    r988 r989  
    1010#include <boost/format.hpp> 
    1111#include <giomm.h> 
     12#include <glibmm/i18n.h> 
    1213 
    1314using boost::get; 
    … …  
    230231    gint64 last_scan_date = boost::get<gint64>(rows[1]["last_scan_date"]); 
    231232 
    232     m_added = 0; 
    233     m_erroneous = 0; 
    234     m_uptodate = 0; 
    235     m_updated = 0; 
    236     m_total = 0; 
     233    m_ScanSummary = ScanSummary(); 
    237234 
    238235    for(Util::FileList::const_iterator i = list.begin(); i != list.end(); ++i) 
    … …  
    279276                    insert_path_sql 
    280277            )); 
    281  
    282             pthreaddata->ScanEnd.emit( m_added, m_uptodate, m_updated, m_erroneous, m_total); 
    283278        } 
    284279        catch( Glib::ConvertError & cxe ) 
    … …  
    288283        } 
    289284    } 
     285 
     286    pthreaddata->ScanEnd.emit( m_ScanSummary ); 
    290287} 
    291288 
    … …  
    338335                            { 
    339336                              g_warning( "%s: %s", G_STRLOC, cxe.what() );  
    340                               ++(m_erroneous); 
     337                              ++(m_ScanSummary.FilesErroneous); 
     338                              m_ScanSummary.FileListErroneous.push_back( SSFileInfo( *i2, _("HAL error/No HAL data for this file."))); 
    341339                              err_occured  = true; 
    342340                            } 
    … …  
    344342                            { 
    345343                              g_warning( "%s: %s", G_STRLOC, cxe.what().c_str() );  
    346                               ++(m_erroneous); 
     344                              ++(m_ScanSummary.FilesErroneous); 
     345                              m_ScanSummary.FileListErroneous.push_back( SSFileInfo( *i2, _("URI Conversion Error."))); 
    347346                              err_occured  = true; 
    348347                            } 
    … …  
    351350                            if( !err_occured ) 
    352351                            { 
    353                                     try{  
    354                                         if (!Audio::typefind(*i2, type))   
    355                                         { 
    356                                           ++(m_erroneous) ; 
    357                                           continue; 
    358                                         } 
    359                                       }   
    360                                     catch (Glib::ConvertError & cxe) 
    361                                       { 
    362                                           ++(m_erroneous) ; 
    363                                           continue; 
    364                                       }    
    365  
    366                                     track[ATTRIBUTE_TYPE] = type ; 
    367  
    368352                                    Glib::RefPtr<Gio::File> file = Gio::File::create_for_uri((*i2).c_str());  
    369353                                    Glib::RefPtr<Gio::FileInfo> info = file->query_info(G_FILE_ATTRIBUTE_TIME_MODIFIED, Gio::FILE_QUERY_INFO_NONE); 
    … …  
    374358                                    if (mtime != 0 && mtime == get<gint64>(track[ATTRIBUTE_MTIME].get())) 
    375359                                    { 
    376                                         ++m_uptodate; 
     360                                        ++m_ScanSummary.FilesUpToDate; 
    377361                                    } 
    378362                                    else 
    … …  
    380364                                        if( !m_MetadataReaderTagLib.get( *i2, track ) ) 
    381365                                        { 
    382                                            ++m_erroneous; 
     366                                           ++m_ScanSummary.FilesErroneous; 
     367                                           m_ScanSummary.FileListErroneous.push_back( SSFileInfo( *i2, _("Could not acquire metadata using taglib-gio."))); 
    383368                                        } 
    384369                                        else try{ 
    … …  
    388373                                            { 
    389374                                                case SCAN_RESULT_OK: 
    390                                                     ++m_added; 
     375                                                    ++m_ScanSummary.FilesAdded; 
    391376                                                    break; 
    392377 
    393378                                                case SCAN_RESULT_ERROR: 
    394                                                     ++m_erroneous; 
     379                                                    ++m_ScanSummary.FilesErroneous; 
     380                                                    m_ScanSummary.FileListErroneous.push_back( SSFileInfo( *i2, _("Error inserting file into database."))); 
    395381                                                    break; 
    396382 
    397383                                                case SCAN_RESULT_UPDATE: 
    398                                                     ++m_updated; 
     384                                                    ++m_ScanSummary.FilesUpdated; 
     385                                                    m_ScanSummary.FileListUpdated.push_back( SSFileInfo( *i2, _("Updated."))); 
    399386                                                    break; 
    400387                                            } 
    … …  
    414401        } 
    415402    } 
    416  
    417     pthreaddata->ScanRun.emit( m_total++, 0 ); 
     403     
     404    m_ScanSummary.FilesTotal++; 
     405 
     406    if( m_ScanSummary.FilesTotal % 50 ) 
     407    { 
     408        pthreaddata->ScanRun.emit( m_ScanSummary.FilesTotal, 0 ); 
     409    } 
    418410} 
    419411 
    … …  
    427419    m_SQL->exec_sql( "UPDATE album SET album_new = 0" ); 
    428420 
    429     gint64 added = 0, erroneous = 0, uptodate = 0, updated = 0, total = 0; 
     421    m_ScanSummary = ScanSummary(); 
    430422 
    431423    Util::FileList collection; 
    … …  
    466458            collection.clear(); 
    467459            Util::collect_audio_paths_recursive( insert_path, collection ); 
    468             total += collection.size(); 
     460            m_ScanSummary.FilesTotal += collection.size(); 
    469461        } 
    470462        catch( Glib::ConvertError & cxe ) 
    … …  
    478470                if( g_atomic_int_get(&pthreaddata->m_ScanStop) ) 
    479471                { 
    480                     pthreaddata->ScanEnd.emit(added, uptodate, updated, erroneous, collection.size()); 
     472                    pthreaddata->ScanEnd.emit( m_ScanSummary );  
    481473                    return; 
    482474                } 
    … …  
    489481                try{ 
    490482 
    491                     URI u (*i, true); 
    492  
    493                     if(u.get_protocol() == URI::PROTOCOL_FILE) 
     483                    URI u( *i3, true ); 
     484 
     485                    if( u.get_protocol() == URI::PROTOCOL_FILE ) 
    494486                    { 
    495  
    496487                        bool err_occured = false; 
    497488 
    498         #ifdef HAVE_HAL 
     489#ifdef HAVE_HAL 
    499490                        try{ 
    500491 
    … …  
    517508                        { 
    518509                          g_warning( "%s: %s", G_STRLOC, cxe.what() );  
    519                           ++(erroneous); 
     510                          ++(m_ScanSummary.FilesErroneous); 
    520511                          err_occured  = true; 
    521512                        } 
    … …  
    523514                        { 
    524515                          g_warning( "%s: %s", G_STRLOC, cxe.what().c_str() );  
    525                           ++(erroneous); 
     516                          ++(m_ScanSummary.FilesErroneous); 
    526517                          err_occured  = true; 
    527518                        } 
    528         #endif 
     519#endif 
    529520 
    530521                        if( !err_occured ) 
    531522                        { 
    532                                 try{  
    533                                     if (!Audio::typefind(*i3, type))   
    534                                     { 
    535                                       ++(erroneous) ; 
    536                                       continue; 
    537                                     } 
    538                                   }   
    539                                 catch (Glib::ConvertError & cxe) 
    540                                   { 
    541                                       ++(erroneous) ; 
    542                                       continue; 
    543                                   }    
    544  
    545                                 track[ATTRIBUTE_TYPE] = type ; 
    546  
    547523                                Glib::RefPtr<Gio::File> file = Gio::File::create_for_uri((*i3).c_str());  
    548524                                Glib::RefPtr<Gio::FileInfo> info = file->query_info(G_FILE_ATTRIBUTE_TIME_MODIFIED, Gio::FILE_QUERY_INFO_NONE); 
    … …  
    553529                                if (mtime != 0 && mtime == get<gint64>(track[ATTRIBUTE_MTIME].get())) 
    554530                                { 
    555                                     ++(uptodate); 
     531                                    ++(m_ScanSummary.FilesUpToDate); 
    556532                                } 
    557533                                else 
    … …  
    559535                                    if( !m_MetadataReaderTagLib.get( *i3, track ) ) 
    560536                                    { 
    561                                        ++(erroneous) ; 
     537                                        ++m_ScanSummary.FilesErroneous; 
     538                                        m_ScanSummary.FileListErroneous.push_back( SSFileInfo( *i3, _("Could not acquire metadata using taglib-gio."))); 
    562539                                    } 
    563540                                    else try{ 
    564541                                        ScanResult status = insert( track, *i3, insert_path_sql ); 
    565542 
    566                                         switch(status) 
     543                                        switch( status ) 
    567544                                        { 
    568545                                            case SCAN_RESULT_OK: 
    569                                                 ++(added) ; 
     546                                                ++m_ScanSummary.FilesAdded; 
    570547                                                break; 
    571548 
    572549                                            case SCAN_RESULT_ERROR: 
    573                                                 ++(erroneous) ; 
     550                                                ++m_ScanSummary.FilesErroneous; 
     551                                                m_ScanSummary.FileListErroneous.push_back( SSFileInfo( *i3, _("Error inserting file into database."))); 
    574552                                                break; 
    575553 
    576554                                            case SCAN_RESULT_UPDATE: 
    577                                                 ++(updated) ; 
     555                                                ++m_ScanSummary.FilesUpdated; 
     556                                                m_ScanSummary.FileListUpdated.push_back( SSFileInfo( *i3, _("Updated."))); 
    578557                                                break; 
    579558                                        } 
    580                                     } 
    581                                     catch( Glib::ConvertError & cxe ) 
    582                                     { 
     559                                     } 
     560                                     catch( Glib::ConvertError & cxe ) 
     561                                     { 
    583562                                        g_warning("%s: %s", G_STRLOC, cxe.what().c_str() ); 
    584                                     } 
     563                                     } 
    585564                                } 
    586565                        } 
    … …  
    597576    } 
    598577 
    599     pthreaddata->ScanEnd.emit(added, uptodate, updated, erroneous, total); 
     578    pthreaddata->ScanEnd.emit( m_ScanSummary ); 
    600579} 
    601580 

  • mpx/mlibmanager.cc

    r986 r989  
    212212 
    213213    void 
    214     MLibManager::scan_end (gint64,gint64,gint64,gint64,gint64) 
     214    MLibManager::scan_end( ScanSummary const& ) 
    215215    { 
    216216        Gtk::Widget::set_sensitive(true); 

  • mpx/mlibmanager.hh

    r979 r989  
    7171 
    7272            void 
    73             scan_end (gint64,gint64,gint64,gint64,gint64); 
     73            scan_end( ScanSummary const& ); 
    7474 
    7575            void 
    7676            scan_start (); 
    7777 
     78 
    7879            void 
    7980            populate_volumes (); 
    8081 
     82 
    8183            void 
    8284            build_fstree (std::string const& root_path); 
    83  
    84             void 
    85             append_path (std::string const& root_path, Gtk::TreeIter & root_iter); 
    86  
    87             void 
    88             prescan_path (std::string const& path, Gtk::TreeIter & iter); 
    8985 
    9086            int 
    9187            fstree_sort (const Gtk::TreeIter & iter_a, const Gtk::TreeIter & iter_b); 
     88 
     89            void 
     90            append_path (std::string const& root_path, Gtk::TreeIter & root_iter); 
     91 
     92            void 
     93            prescan_path (std::string const& path, Gtk::TreeIter & iter); 
    9294 
    9395            bool 

  • mpx/mpx.cc

    r983 r989  
    20462046 
    20472047        void 
    2048                 Player::unmount_ready_callback (Glib::RefPtr<Gio::AsyncResult>& res) 
     2048                Player::unmount_ready_callback( Glib::RefPtr<Gio::AsyncResult>& res ) 
    20492049                { 
    20502050                } 
    … …  
    20582058 
    20592059        void 
    2060                 Player::on_library_scan_run(gint64 x, gint64 y) 
     2060                Player::on_library_scan_run( gint64 a, gint64 b ) 
    20612061                { 
    20622062                        m_Statusbar->pop(); 
    2063                         m_Statusbar->push((boost::format(_("Library Scan: %1% / %2%")) % x % y).str()); 
    2064                 } 
    2065  
    2066         void 
    2067                 Player::on_library_scan_end(gint64 x, gint64 y, gint64 a, gint64 b, gint64 s) 
     2063                        m_Statusbar->push((boost::format(_("Library Scan: %1% Items")) % a).str()); 
     2064                } 
     2065 
     2066        void 
     2067                Player::on_library_scan_end( ScanSummary const& summary ) 
    20682068                { 
    20692069                        m_Statusbar->pop();         
    2070                         m_Statusbar->push((boost::format(_("Library Scan: Done (%1% Items (files/folders) scanned, %2% files added, %3% files up to date, %4% updated, %5% erroneous)")) % s % x % y % a % b).str()); 
     2070                        m_Statusbar->push((boost::format(_("Library Scan: Done (%1% Items scanned, %2% Files added, %3% Files up to date, %4% updated, %5% erroneous)")) % summary.FilesTotal % summary.FilesAdded % summary.FilesUpToDate % summary.FilesUpdated % summary.FilesErroneous ).str()); 
    20712071                        m_Library.execSQL((boost::format ("INSERT INTO meta (last_scan_date) VALUES (%lld)") % (gint64(time(NULL)))).str()); 
    20722072                } 

  • mpx/mpx.hh

    r954 r989  
    348348 
    349349        void 
    350         on_library_scan_end(gint64,gint64,gint64,gint64,gint64); 
     350        on_library_scan_end(ScanSummary const&); 
    351351 
    352352