Changeset 507


Ignore:
Timestamp:
07/20/08 17:16:57 (11 years ago)
Author:
Eoin
Message:

Added ListViewIterators?.hpp.

Major find and replace of TorrentDetails? and associated classes to torrent_details.

Location:
trunk
Files:
1 added
28 edited

Legend:

Unmodified
Added
Removed
  • trunk/res/Halite.rc

    r505 r507  
    463463    PUSHBUTTON      "Apply",HAL_TRACKER_APPLY,126,3,32,14,WS_DISABLED 
    464464    PUSHBUTTON      "Reset",HAL_TRACKER_RESET,92,3,32,14 
     465    AUTOCHECKBOX    "Send login info to trackers.",HAL_TRACKER_LOGINCHECK,166,4,101,12 
     466    EDITTEXT        HAL_TRACKER_USER,208,18,92,12,ES_AUTOHSCROLL 
     467    EDITTEXT        HAL_TRACKER_PASS,208,32,92,12,ES_AUTOHSCROLL | ES_PASSWORD 
     468    RTEXT           "Username : ",HAL_TRACKER_USER_S,164,20,42,8,SS_WORDELLIPSIS|SS_CENTERIMAGE 
     469    RTEXT           "Password : ",HAL_TRACKER_PASS_S,164,34,42,8,SS_WORDELLIPSIS|SS_CENTERIMAGE 
     470    CONTROL         "",HAL_TRACKERLIST,"SysListView32",WS_BORDER | LVS_ALIGNLEFT | LVS_REPORT,4,19,154,47 
     471    PUSHBUTTON      "Apply",HAL_LOGIN_APPLY,207,46,51,14,BS_DEFPUSHBUTTON 
     472    PUSHBUTTON      "Reannounce",HAL_REANNOUNCE,207,46,51,14 
     473END 
     474 
     475HAL_ADVQUEUE DIALOGEX 0,0,305,69 
     476STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILDWINDOW 
     477FONT 8,"MS Shell Dlg",400,0,1 
     478BEGIN 
    465479    AUTOCHECKBOX    "Send login info to trackers.",HAL_TRACKER_LOGINCHECK,166,4,101,12 
    466480    EDITTEXT        HAL_TRACKER_USER,208,18,92,12,ES_AUTOHSCROLL 
  • trunk/sln/Halite/Halite.vcproj

    r503 r507  
    10731073                                </File> 
    10741074                                <File 
     1075                                        RelativePath="..\..\src\advtabs\Queue.hpp" 
     1076                                        > 
     1077                                </File> 
     1078                                <File 
    10751079                                        RelativePath="..\..\src\advtabs\ThemeTestDialog.hpp" 
    10761080                                        > 
  • trunk/src/HaliteDialog.cpp

    r495 r507  
    9999void HaliteDialog::OnPause(UINT, int, HWND) 
    100100{ 
    101         if (hal::TorrentDetail_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent())  
     101        if (hal::torrent_details_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent())  
    102102        { 
    103103                string torrentName = hal::to_utf8(torrent->name()); 
     
    120120void HaliteDialog::OnReannounce(UINT, int, HWND) 
    121121{ 
    122         if (hal::TorrentDetail_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent())  
     122        if (hal::torrent_details_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent())  
    123123                hal::bittorrent().reannounceTorrent(hal::to_utf8(torrent->name())); 
    124124} 
     
    126126void HaliteDialog::OnRemove(UINT, int, HWND) 
    127127{ 
    128         if (hal::TorrentDetail_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent())  
     128        if (hal::torrent_details_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent())  
    129129        { 
    130130                string torrentName = hal::to_utf8(torrent->name()); 
     
    153153} 
    154154 
    155 void HaliteDialog::DialogListView::uiUpdate(const hal::TorrentDetails& tD)  
     155void HaliteDialog::DialogListView::uiUpdate(const hal::torrent_details_manager& tD)  
    156156{        
    157157        hal::try_update_lock<listClass> lock(*this); 
     
    213213} 
    214214 
    215 void HaliteDialog::focusChanged(const hal::TorrentDetail_ptr pT) 
     215void HaliteDialog::focusChanged(const hal::torrent_details_ptr pT) 
    216216{ 
    217217        std::pair<float, float> tranLimit(-1.0, -1.0); 
     
    268268} 
    269269 
    270 void HaliteDialog::uiUpdate(const hal::TorrentDetails& tD) 
     270void HaliteDialog::uiUpdate(const hal::torrent_details_manager& tD) 
    271271{        
    272272        std::pair<float, float> tranLimit(-1.0, -1.0); 
    273273        std::pair<int, int> connLimit(-1, -1); 
    274274         
    275         if (hal::TorrentDetail_ptr torrent = tD.focusedTorrent())        
     275        if (hal::torrent_details_ptr torrent = tD.focusedTorrent())      
    276276        {        
    277277                string torrent_name = hal::to_utf8(torrent->name()); 
  • trunk/src/HaliteDialog.hpp

    r495 r507  
    147147                }                
    148148                 
    149                 void uiUpdate(const hal::TorrentDetails& tD); 
     149                void uiUpdate(const hal::torrent_details_manager& tD); 
    150150                 
    151151        private: 
     
    183183        static CWindowMapStruct* GetWindowMap(); 
    184184         
    185         void uiUpdate(const hal::TorrentDetails& allTorrents);  
    186         void focusChanged(const hal::TorrentDetail_ptr pT); 
     185        void uiUpdate(const hal::torrent_details_manager& allTorrents);  
     186        void focusChanged(const hal::torrent_details_ptr pT); 
    187187         
    188188protected: 
  • trunk/src/HaliteDialogBase.hpp

    r478 r507  
    6464        #define logical_xor !=0==! 
    6565         
    66         void handleUiUpdate(const hal::TorrentDetails& tD) 
     66        void handleUiUpdate(const hal::torrent_details_manager& tD) 
    6767        { 
    6868                TBase* pT = static_cast<TBase*>(this); 
    6969                 
    70                 hal::TorrentDetail_ptr focused = tD.focusedTorrent(); 
     70                hal::torrent_details_ptr focused = tD.focusedTorrent(); 
    7171                 
    7272                if ((focusedTorrent_ logical_xor focused) || 
     
    8484        } 
    8585 
    86         void uiUpdate(const hal::TorrentDetails& tD) 
     86        void uiUpdate(const hal::torrent_details_manager& tD) 
    8787        {}       
    8888         
    89         void focusChanged(const hal::TorrentDetail_ptr pT) 
     89        void focusChanged(const hal::torrent_details_ptr pT) 
    9090        {} 
    9191         
    92         const hal::TorrentDetail_ptr focusedTorrent() { return focusedTorrent_; } 
     92        const hal::torrent_details_ptr focusedTorrent() { return focusedTorrent_; } 
    9393         
    9494        template<typename T> 
     
    102102         
    103103protected: 
    104         hal::TorrentDetail_ptr focusedTorrent_; 
     104        hal::torrent_details_ptr focusedTorrent_; 
    105105 
    106106private: 
  • trunk/src/HaliteListView.cpp

    r503 r507  
    7979} 
    8080 
    81 void HaliteListViewCtrl::uiUpdate(const hal::TorrentDetails& tD) 
     81void HaliteListViewCtrl::uiUpdate(const hal::torrent_details_manager& tD) 
    8282{ 
    8383        hal::try_update_lock<listClass> lock(*this); 
     
    8585        { 
    8686         
    87         foreach (const hal::TorrentDetail_ptr td, tD.torrents())  
     87        foreach (const hal::torrent_details_ptr td, tD.torrents())  
    8888        { 
    8989                LV_FINDINFO findInfo;  
  • trunk/src/HaliteListView.hpp

    r495 r507  
    3030 
    3131class HaliteListViewCtrl : 
    32         public CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::TorrentDetail_ptr>, 
     32        public CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::torrent_details_ptr>, 
    3333        private hal::IniBase<HaliteListViewCtrl>, 
    3434        private boost::noncopyable 
     
    3636protected: 
    3737        typedef hal::IniBase<HaliteListViewCtrl> iniClass; 
    38         typedef CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::TorrentDetail_ptr> listClass; 
    39         typedef const hal::TorrentDetail_ptr tD; 
     38        typedef CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::torrent_details_ptr> listClass; 
     39        typedef const hal::torrent_details_ptr tD; 
    4040 
    4141        friend class listClass; 
     
    357357        void OnDestroy(); 
    358358        void saveSettings(); 
    359         void uiUpdate(const hal::TorrentDetails& allTorrents);  
     359        void uiUpdate(const hal::torrent_details_manager& allTorrents);  
    360360 
    361361        LRESULT OnPause(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
  • trunk/src/HaliteListViewCtrl.hpp

    r493 r507  
    241241        }; 
    242242         
    243         // EG T is a TorrentDetail, so have array column_types 
     243        // EG T is a torrent_details, so have array column_types 
    244244 
    245245public: 
  • trunk/src/HaliteWindow.cpp

    r495 r507  
    309309        { 
    310310         
    311         const hal::TorrentDetails& torrents = hal::bittorrent().updateTorrentDetails( 
     311        const hal::torrent_details_manager& torrents = hal::bittorrent().updatetorrent_details_manager( 
    312312                haliteList.manager().selected(), haliteList.manager().allSelected()); 
    313313 
  • trunk/src/HaliteWindow.hpp

    r495 r507  
    106106        void ProcessFile(LPCTSTR lpszPath); 
    107107         
    108         boost::signals::connection connectUiUpdate(boost::function<void (const hal::TorrentDetails& allTorrents)> fn)  
     108        boost::signals::connection connectUiUpdate(boost::function<void (const hal::torrent_details_manager& allTorrents)> fn)  
    109109        {  
    110110                return ui_update_signal_.connect(fn);  
    111111        } 
    112112         
    113         boost::signal<void (const hal::TorrentDetails& allTorrents)> & ui_sig() 
     113        boost::signal<void (const hal::torrent_details_manager& allTorrents)> & ui_sig() 
    114114        {  
    115115                return ui_update_signal_;  
     
    195195 
    196196        // These two gotta be first!!! 
    197         boost::signal<void (const hal::TorrentDetails& tD)> ui_update_signal_; 
     197        boost::signal<void (const hal::torrent_details_manager& tD)> ui_update_signal_; 
    198198        boost::signal<void ()> save_state_signal_;       
    199199         
  • trunk/src/NewTorrentDialog.hpp

    r495 r507  
    8989        END_MSG_MAP() 
    9090 
    91         void uiUpdate(const hal::TorrentDetail_ptr pT); 
     91        void uiUpdate(const hal::torrent_details_ptr pT); 
    9292 
    9393    friend class boost::serialization::access; 
  • trunk/src/NewTorrentPeersLV.hpp

    r491 r507  
    7070        END_MSG_MAP() 
    7171 
    72         void uiUpdate(const hal::TorrentDetail_ptr pT); 
     72        void uiUpdate(const hal::torrent_details_ptr pT); 
    7373        void saveSettings(); 
    7474 
  • trunk/src/NewTorrentTrackerLV.cpp

    r492 r507  
    3333} 
    3434 
    35 void NewTorrent_TrackerListViewCtrl::uiUpdate(const hal::TorrentDetail_ptr pT) 
     35void NewTorrent_TrackerListViewCtrl::uiUpdate(const hal::torrent_details_ptr pT) 
    3636{ 
    3737        if (hal::bit::torrent t = hal::bittorrent().get(pT)) 
  • trunk/src/NewTorrentTrackerLV.hpp

    r491 r507  
    6969        END_MSG_MAP() 
    7070 
    71         void uiUpdate(const hal::TorrentDetail_ptr pT); 
     71        void uiUpdate(const hal::torrent_details_ptr pT); 
    7272        void saveSettings(); 
    7373 
  • trunk/src/advtabs/Files.cpp

    r495 r507  
    104104        hal::FileDetails fileDetails; 
    105105         
    106         if (hal::TorrentDetail_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent()) 
     106        if (hal::torrent_details_ptr torrent = hal::bittorrent().torrentDetails().focusedTorrent()) 
    107107        { 
    108108                std::copy(torrent->fileDetails().begin(), torrent->fileDetails().end(),  
     
    236236} 
    237237 
    238 void AdvFilesDialog::uiUpdate(const hal::TorrentDetails& tD) 
     238void AdvFilesDialog::uiUpdate(const hal::torrent_details_manager& tD) 
    239239{ 
    240240        list_.setFocused(focusedTorrent()); 
     
    296296} 
    297297 
    298 void AdvFilesDialog::focusChanged(const hal::TorrentDetail_ptr pT) 
     298void AdvFilesDialog::focusChanged(const hal::torrent_details_ptr pT) 
    299299{ 
    300300        fileLinks_.clear(); 
  • trunk/src/advtabs/Files.hpp

    r495 r507  
    204204        }                
    205205         
    206         void setFocused(const hal::TorrentDetail_ptr& f) { focused_ = f; } 
    207         const hal::TorrentDetail_ptr focused() { return focused_; } 
     206        void setFocused(const hal::torrent_details_ptr& f) { focused_ = f; } 
     207        const hal::torrent_details_ptr focused() { return focused_; } 
    208208 
    209209private: 
    210         hal::TorrentDetail_ptr focused_; 
     210        hal::torrent_details_ptr focused_; 
    211211}; 
    212212 
     
    441441        void DlgResize_UpdateLayout(int cxWidth, int cyHeight); 
    442442        void doUiUpdate(); 
    443         void uiUpdate(const hal::TorrentDetails& tD); 
    444         void focusChanged(const hal::TorrentDetail_ptr pT); 
     443        void uiUpdate(const hal::torrent_details_manager& tD); 
     444        void focusChanged(const hal::torrent_details_ptr pT); 
    445445        void OnDestroy(); 
    446446 
  • trunk/src/advtabs/Peers.cpp

    r495 r507  
    1414#include "Peers.hpp" 
    1515 
    16 void PeerListView::uiUpdate(const hal::TorrentDetails& tD) 
     16void PeerListView::uiUpdate(const hal::torrent_details_manager& tD) 
    1717{ 
    1818        hal::try_update_lock<listClass> lock(*this); 
     
    2121                peerDetails_.clear(); 
    2222                 
    23                 foreach (const hal::TorrentDetail_ptr torrent, tD.selectedTorrents()) 
     23                foreach (const hal::torrent_details_ptr torrent, tD.selectedTorrents()) 
    2424                { 
    2525                        std::copy(torrent->peerDetails().begin(), torrent->peerDetails().end(),  
     
    8282} 
    8383 
    84 void AdvPeerDialog::uiUpdate(const hal::TorrentDetails& tD) 
     84void AdvPeerDialog::uiUpdate(const hal::torrent_details_manager& tD) 
    8585{ 
    8686        peerList_.uiUpdate(tD); 
  • trunk/src/advtabs/Peers.hpp

    r495 r507  
    123123        }                
    124124 
    125         void uiUpdate(const hal::TorrentDetails& tD); 
     125        void uiUpdate(const hal::torrent_details_manager& tD); 
    126126         
    127127private: 
     
    172172        void OnClose(); 
    173173         
    174         void uiUpdate(const hal::TorrentDetails& tD); 
     174        void uiUpdate(const hal::torrent_details_manager& tD); 
    175175 
    176176protected: 
  • trunk/src/advtabs/Torrent.cpp

    r495 r507  
    9898 
    9999 
    100 void AdvTorrentDialog::focusChanged(const hal::TorrentDetail_ptr pT) 
     100void AdvTorrentDialog::focusChanged(const hal::torrent_details_ptr pT) 
    101101{ 
    102102        std::pair<float, float> tranLimit(-1.0, -1.0); 
     
    148148} 
    149149 
    150 void AdvTorrentDialog::uiUpdate(const hal::TorrentDetails& tD) 
     150void AdvTorrentDialog::uiUpdate(const hal::torrent_details_manager& tD) 
    151151{        
    152         if (hal::TorrentDetail_ptr torrent = tD.focusedTorrent())        
     152        if (hal::torrent_details_ptr torrent = tD.focusedTorrent())      
    153153        {                        
    154154                uiUpdateSingle(torrent);         
     
    156156} 
    157157 
    158 void AdvTorrentDialog::uiUpdateSingle(const hal::TorrentDetail_ptr& torrent) 
     158void AdvTorrentDialog::uiUpdateSingle(const hal::torrent_details_ptr& torrent) 
    159159{        
    160160        if (torrent)     
     
    228228} 
    229229 
    230 void AdvTorrentDialog::uiUpdateMultiple(const hal::TorrentDetail_vec& torrents) 
     230void AdvTorrentDialog::uiUpdateMultiple(const hal::torrent_details_vec& torrents) 
    231231{} 
    232232 
  • trunk/src/advtabs/Torrent.hpp

    r495 r507  
    9393        LRESULT OnHalEditChanged(UINT uMsg, WPARAM wParam, LPARAM lParam); 
    9494 
    95         void uiUpdate(const hal::TorrentDetails& tD); 
    96         void uiUpdateMultiple(const hal::TorrentDetail_vec& torrents); 
    97         void uiUpdateSingle(const hal::TorrentDetail_ptr& torrent); 
     95        void uiUpdate(const hal::torrent_details_manager& tD); 
     96        void uiUpdateMultiple(const hal::torrent_details_vec& torrents); 
     97        void uiUpdateSingle(const hal::torrent_details_ptr& torrent); 
    9898        void uiUpdateNone(); 
    99         void focusChanged(const hal::TorrentDetail_ptr pT); 
     99        void focusChanged(const hal::torrent_details_ptr pT); 
    100100 
    101101protected: 
  • trunk/src/advtabs/Tracker.cpp

    r495 r507  
    6868} 
    6969 
    70 void AdvTrackerDialog::focusChanged(const hal::TorrentDetail_ptr pT) 
     70void AdvTrackerDialog::focusChanged(const hal::torrent_details_ptr pT) 
    7171{                
    7272        if (pT) 
     
    9797} 
    9898 
    99 void AdvTrackerDialog::uiUpdate(const hal::TorrentDetails& tD) 
     99void AdvTrackerDialog::uiUpdate(const hal::torrent_details_manager& tD) 
    100100{} 
    101101 
  • trunk/src/advtabs/Tracker.hpp

    r495 r507  
    9191 
    9292        void setLoginUiState();  
    93         void uiUpdate(const hal::TorrentDetails& tD); 
    94         void focusChanged(const hal::TorrentDetail_ptr pT); 
     93        void uiUpdate(const hal::torrent_details_manager& tD); 
     94        void focusChanged(const hal::torrent_details_ptr pT); 
    9595        void trackerListEdited(); 
    9696 
  • trunk/src/advtabs/TrackerListView.cpp

    r492 r507  
    3333} 
    3434 
    35 void TrackerListViewCtrl::uiUpdate(const hal::TorrentDetail_ptr pT) 
     35void TrackerListViewCtrl::uiUpdate(const hal::torrent_details_ptr pT) 
    3636{ 
    3737        if (hal::bit::torrent t = hal::bittorrent().get(pT)) 
  • trunk/src/advtabs/TrackerListView.hpp

    r495 r507  
    6868        END_MSG_MAP() 
    6969 
    70         void uiUpdate(const hal::TorrentDetail_ptr pT); 
     70        void uiUpdate(const hal::torrent_details_ptr pT); 
    7171        void enterNewTracker(); 
    7272        void saveSettings(); 
  • trunk/src/halSession.hpp

    r506 r507  
    797797                                switch ((*i).torrent->state()) 
    798798                                { 
    799                                         case TorrentDetail::torrent_stopped: 
     799                                        case torrent_details::torrent_stopped: 
    800800                                                break; 
    801                                         case TorrentDetail::torrent_paused: 
     801                                        case torrent_details::torrent_paused: 
    802802                                                (*i).torrent->add_to_session(true); 
    803803                                                break; 
    804                                         case TorrentDetail::torrent_active: 
     804                                        case torrent_details::torrent_active: 
    805805                                                (*i).torrent->add_to_session(false); 
    806806                                                break; 
     
    860860                                        i != e; ++i) 
    861861                        { 
    862                                 if ((*i).torrent->state() != TorrentDetail::torrent_stopped) 
     862                                if ((*i).torrent->state() != torrent_details::torrent_stopped) 
    863863                                        ++num_active; 
    864864                        } 
  • trunk/src/halTorrent.cpp

    r506 r507  
    4949} 
    5050 
    51 const PeerDetails& TorrentDetail::peerDetails() const 
     51const PeerDetails& torrent_details::peerDetails() const 
    5252{ 
    5353        if (!peerDetailsFilled_) 
     
    6060} 
    6161 
    62 const FileDetails& TorrentDetail::fileDetails() const 
     62const FileDetails& torrent_details::fileDetails() const 
    6363{ 
    6464        if (!fileDetailsFilled_) 
     
    7171} 
    7272 
    73 bool nameLess(const TorrentDetail_ptr& left, const TorrentDetail_ptr& right) 
     73bool nameLess(const torrent_details_ptr& left, const torrent_details_ptr& right) 
    7474{ 
    7575        return left->state() < right->state(); 
    7676} 
    7777 
    78 void TorrentDetails::sort( 
    79         boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const 
     78void torrent_details_manager::sort( 
     79        boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const 
    8080{ 
    8181        std::stable_sort(torrents_.begin(), torrents_.end(), fn); 
     
    302302} 
    303303 
    304 const TorrentDetails& bit::torrentDetails() 
     304const torrent_details_manager& bit::torrentDetails() 
    305305{ 
    306306        return torrentDetails_; 
    307307} 
    308308 
    309 const TorrentDetails& bit::updateTorrentDetails(const wstring& focused, const std::set<wstring>& selected) 
     309const torrent_details_manager& bit::updatetorrent_details_manager(const wstring& focused, const std::set<wstring>& selected) 
    310310{ 
    311311        try { 
     
    319319        { 
    320320                wstring utf8Name = (*i).torrent->name(); 
    321                 TorrentDetail_ptr pT = (*i).torrent->getTorrentDetail_ptr(); 
     321                torrent_details_ptr pT = (*i).torrent->gettorrent_details_ptr(); 
    322322                 
    323323                if (selected.find(utf8Name) != selected.end()) 
     
    333333        } 
    334334         
    335         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updateTorrentDetails") 
     335        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "updatetorrent_details_manager") 
    336336         
    337337        return torrentDetails_; 
     
    570570                i != e; ++i) 
    571571        { 
    572                 if ((*i).torrent->in_session() && (*i).torrent->state() == TorrentDetail::torrent_paused) 
     572                if ((*i).torrent->in_session() && (*i).torrent->state() == torrent_details::torrent_paused) 
    573573                        (*i).torrent->resume(); 
    574574        } 
  • trunk/src/halTorrent.hpp

    r506 r507  
    196196typedef std::vector<FileDetail> FileDetails; 
    197197 
    198 class TorrentDetail  
     198class torrent_details  
    199199{ 
    200200public: 
    201         TorrentDetail(std::wstring n, std::wstring f, std::wstring sd, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
     201        torrent_details(std::wstring n, std::wstring f, std::wstring sd, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
    202202                        float c=0, float d=0, size_type tWD=0, size_type tW=0, size_type tU=0, size_type tpU=0, size_type tD=0, size_type tpD=0, boost::tuple<size_type, size_type, size_type, size_type> connections = boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), float r=0,  
    203203                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0), boost::posix_time::time_duration uIn=boost::posix_time::seconds(0), 
     
    232232        {} 
    233233 
    234         TorrentDetail() :        
     234        torrent_details() :      
    235235                peerDetailsFilled_(false), 
    236236                fileDetailsFilled_(false) 
     
    322322}; 
    323323 
    324 typedef boost::shared_ptr<TorrentDetail> TorrentDetail_ptr; 
    325 typedef boost::scoped_ptr<TorrentDetail> TorrentDetail_sptr; 
    326 typedef boost::weak_ptr<TorrentDetail> TorrentDetail_wptr; 
    327 typedef std::vector<TorrentDetail_ptr> TorrentDetail_vec; 
    328 typedef std::map<std::wstring, TorrentDetail_ptr> TorrentDetail_map; 
    329  
    330 class TorrentDetails 
     324typedef boost::shared_ptr<torrent_details> torrent_details_ptr; 
     325typedef boost::scoped_ptr<torrent_details> torrent_details_sptr; 
     326typedef boost::weak_ptr<torrent_details> torrent_details_wptr; 
     327typedef std::vector<torrent_details_ptr> torrent_details_vec; 
     328typedef std::map<std::wstring, torrent_details_ptr> torrent_details_map; 
     329 
     330class torrent_details_manager 
    331331{ 
    332332public:  
    333         void sort(boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const; 
    334          
    335         const TorrentDetail_vec torrents() const  
     333        void sort(boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const; 
     334         
     335        const torrent_details_vec torrents() const  
    336336        { 
    337337                mutex_t::scoped_lock l(mutex_);  
     
    339339        } 
    340340         
    341         const TorrentDetail_vec selectedTorrents() const  
     341        const torrent_details_vec selectedTorrents() const  
    342342        {  
    343343                mutex_t::scoped_lock l(mutex_);  
     
    345345        } 
    346346         
    347         const TorrentDetail_ptr focusedTorrent() const  
     347        const torrent_details_ptr focusedTorrent() const  
    348348        { 
    349349                mutex_t::scoped_lock l(mutex_);  
     
    351351        } 
    352352         
    353         const TorrentDetail_ptr get(std::wstring filename) const 
     353        const torrent_details_ptr get(std::wstring filename) const 
    354354        { 
    355355                mutex_t::scoped_lock l(mutex_);  
    356356                 
    357                 TorrentDetail_map::const_iterator i = torrentMap_.find(filename); 
     357                torrent_details_map::const_iterator i = torrentMap_.find(filename); 
    358358                 
    359359                if (i != torrentMap_.end()) 
    360360                        return i->second; 
    361361                else 
    362                         return TorrentDetail_ptr(); 
     362                        return torrent_details_ptr(); 
    363363        } 
    364364         
     
    377377        } 
    378378 
    379         mutable TorrentDetail_vec torrents_; 
    380          
    381         TorrentDetail_map torrentMap_; 
    382         TorrentDetail_vec selectedTorrents_; 
    383         TorrentDetail_ptr selectedTorrent_; 
     379        mutable torrent_details_vec torrents_; 
     380         
     381        torrent_details_map torrentMap_; 
     382        torrent_details_vec selectedTorrents_; 
     383        torrent_details_ptr selectedTorrent_; 
    384384         
    385385        mutable mutex_t mutex_; 
     
    621621         
    622622        template<> 
    623         torrent get(const hal::TorrentDetail_ptr t) 
     623        torrent get(const hal::torrent_details_ptr t) 
    624624        { 
    625625                if (t)  
     
    716716        float defTorrentUpload();        
    717717 
    718         const TorrentDetails& torrentDetails(); 
    719         const TorrentDetails& updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected); 
     718        const torrent_details_manager& torrentDetails(); 
     719        const torrent_details_manager& updatetorrent_details_manager(const std::wstring& focused, const std::set<std::wstring>& selected); 
    720720         
    721721private: 
     
    728728        void remove_torrent_wipe_files_wstr(const std::wstring&  filename); 
    729729         
    730         TorrentDetails torrentDetails_; 
     730        torrent_details_manager torrentDetails_; 
    731731}; 
    732732 
  • trunk/src/halTorrentInternal.hpp

    r496 r507  
    514514                TORRENT_INTERNALS_DEFAULTS, 
    515515                compactStorage_(true), 
    516                 state_(TorrentDetail::torrent_stopped) 
     516                state_(torrent_details::torrent_stopped) 
    517517        {} 
    518518         
     
    522522                move_to_directory_(move_to_directory.string()), 
    523523                compactStorage_(compactStorage),         
    524                 state_(TorrentDetail::torrent_stopped) 
     524                state_(torrent_details::torrent_stopped) 
    525525        { 
    526526                assert(the_session_);            
     
    566566        #undef TORRENT_INTERNALS_DEFAULTS 
    567567         
    568         TorrentDetail_ptr getTorrentDetail_ptr() 
     568        torrent_details_ptr gettorrent_details_ptr() 
    569569        {        
    570570                mutex_t::scoped_lock l(mutex_); 
     
    591591                switch (state_) 
    592592                { 
    593                 case TorrentDetail::torrent_paused: 
     593                case torrent_details::torrent_paused: 
    594594                        state = app().res_wstr(HAL_TORRENT_PAUSED); 
    595595                        break; 
    596596                         
    597                 case TorrentDetail::torrent_pausing: 
     597                case torrent_details::torrent_pausing: 
    598598                        state = app().res_wstr(HAL_TORRENT_PAUSING); 
    599599                        break; 
    600600                         
    601                 case TorrentDetail::torrent_stopped: 
     601                case torrent_details::torrent_stopped: 
    602602                        state = app().res_wstr(HAL_TORRENT_STOPPED); 
    603603                        break; 
    604604                         
    605                 case TorrentDetail::torrent_stopping: 
     605                case torrent_details::torrent_stopping: 
    606606                        state = app().res_wstr(HAL_TORRENT_STOPPING); 
    607607                        break; 
     
    663663                boost::tuple<size_t, size_t, size_t, size_t> connections = updatePeers();        
    664664 
    665                 return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), state, hal::from_utf8(statusMemory_.current_tracker),  
     665                return torrent_details_ptr(new torrent_details(name_, filename_, saveDirectory().string(), state, hal::from_utf8(statusMemory_.current_tracker),  
    666666                        std::pair<float, float>(statusMemory_.download_payload_rate, statusMemory_.upload_payload_rate), 
    667667                        progress_, statusMemory_.distributed_copies, statusMemory_.total_wanted_done, statusMemory_.total_wanted, uploaded_, payloadUploaded_, 
     
    672672                { 
    673673                        event_log.post(shared_ptr<EventDetail>( 
    674                                 new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, to_utf8(name_), "getTorrentDetail_ptr"))); 
     674                                new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, to_utf8(name_), "gettorrent_details_ptr"))); 
    675675                } 
    676676                catch (const std::exception& e) 
    677677                { 
    678678                        event_log.post(shared_ptr<EventDetail>( 
    679                                 new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "getTorrentDetail_ptr"))); 
    680                 } 
    681                  
    682                 return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA))); 
     679                                new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "gettorrent_details_ptr"))); 
     680                } 
     681                 
     682                return torrent_details_ptr(new torrent_details(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA))); 
    683683        } 
    684684 
     
    753753                        in_session_ = true; 
    754754                        if (paused) 
    755                                 state_ = TorrentDetail::torrent_paused;  
     755                                state_ = torrent_details::torrent_paused;        
    756756                        else 
    757                                 state_ = TorrentDetail::torrent_active;  
     757                                state_ = torrent_details::torrent_active;        
    758758                                 
    759759                        applySettings(); 
     
    819819                mutex_t::scoped_lock l(mutex_); 
    820820 
    821                 if (state_ == TorrentDetail::torrent_stopped) 
     821                if (state_ == torrent_details::torrent_stopped) 
    822822                {        
    823823                        add_to_session(false); 
     
    830830                }        
    831831                 
    832                 state_ = TorrentDetail::torrent_active;                  
     832                state_ = torrent_details::torrent_active;                        
    833833                assert(!handle_.is_paused()); 
    834834        } 
     
    838838                mutex_t::scoped_lock l(mutex_); 
    839839 
    840                 if (state_ == TorrentDetail::torrent_stopped) 
     840                if (state_ == torrent_details::torrent_stopped) 
    841841                {        
    842842                        add_to_session(true); 
     
    853853                        signals().torrent_paused.connect_once(bind(&torrent_internal::completed_pause, this)); 
    854854 
    855                         state_ = TorrentDetail::torrent_pausing;         
     855                        state_ = torrent_details::torrent_pausing;       
    856856                }                        
    857857        } 
     
    861861                mutex_t::scoped_lock l(mutex_); 
    862862 
    863                 if (state_ != TorrentDetail::torrent_stopped) 
    864                 { 
    865                         if (state_ == TorrentDetail::torrent_active) 
     863                if (state_ != torrent_details::torrent_stopped) 
     864                { 
     865                        if (state_ == torrent_details::torrent_active) 
    866866                        { 
    867867                                assert(in_session()); 
     
    871871                                handle_.pause(); 
    872872 
    873                                 state_ = TorrentDetail::torrent_stopping; 
     873                                state_ = torrent_details::torrent_stopping; 
    874874                        } 
    875                         else if (state_ == TorrentDetail::torrent_paused) 
     875                        else if (state_ == torrent_details::torrent_paused) 
    876876                        {                        
    877877                                remove_from_session(); 
    878                                 state_ = TorrentDetail::torrent_stopped;                                 
     878                                state_ = torrent_details::torrent_stopped;                               
    879879                        } 
    880880                } 
     
    883883        void set_state_stopped() 
    884884        { 
    885                 state_ = TorrentDetail::torrent_stopped; 
     885                state_ = torrent_details::torrent_stopped; 
    886886        } 
    887887 
     
    893893                switch (state_) 
    894894                { 
    895                 case TorrentDetail::torrent_stopped: 
     895                case torrent_details::torrent_stopped: 
    896896                        clear_resume_data(); 
    897897                        resume(); 
    898898                        break; 
    899899 
    900                 case TorrentDetail::torrent_stopping: 
    901                 case TorrentDetail::torrent_pausing: 
     900                case torrent_details::torrent_stopping: 
     901                case torrent_details::torrent_pausing: 
    902902                        signals().torrent_paused.disconnect_all_once(); 
    903903 
    904                 case TorrentDetail::torrent_active: 
     904                case torrent_details::torrent_active: 
    905905                        signals().torrent_paused.disconnect_all_once(); 
    906906                        signals().torrent_paused.connect_once(bind(&torrent_internal::handle_recheck, this)); 
    907907                        handle_.pause(); 
    908                         state_ = TorrentDetail::torrent_pausing; 
     908                        state_ = torrent_details::torrent_pausing; 
    909909                        break; 
    910910 
     
    10051005        } 
    10061006         
    1007         bool is_active() const { return state_ == TorrentDetail::torrent_active; } 
     1007        bool is_active() const { return state_ == torrent_details::torrent_active; } 
    10081008         
    10091009        unsigned state() const { return state_; } 
     
    12781278                        fs::create_directory(save_directory_); 
    12791279 
    1280                 if (state_ == TorrentDetail::torrent_stopping) 
    1281                         state_ = TorrentDetail::torrent_stopped; 
    1282                 else if (state_ == TorrentDetail::torrent_pausing) 
    1283                         state_ = TorrentDetail::torrent_paused; 
     1280                if (state_ == torrent_details::torrent_stopping) 
     1281                        state_ = torrent_details::torrent_stopped; 
     1282                else if (state_ == torrent_details::torrent_pausing) 
     1283                        state_ = torrent_details::torrent_paused; 
    12841284        } 
    12851285         
     
    14331433                assert(handle_.is_paused());     
    14341434                                 
    1435                 state_ = TorrentDetail::torrent_paused;  
     1435                state_ = torrent_details::torrent_paused;        
    14361436 
    14371437                HAL_DEV_MSG(L"completed_pause()"); 
     
    14441444                assert(handle_.is_paused());     
    14451445                 
    1446                 state_ = TorrentDetail::torrent_stopped; 
     1446                state_ = torrent_details::torrent_stopped; 
    14471447                 
    14481448                remove_from_session(); 
     
    14551455        { 
    14561456                mutex_t::scoped_lock l(mutex_); 
    1457                 state_ = TorrentDetail::torrent_stopped; 
     1457                state_ = torrent_details::torrent_stopped; 
    14581458 
    14591459                remove_from_session(false); 
Note: See TracChangeset for help on using the changeset viewer.