Changeset 243


Ignore:
Timestamp:
08/01/07 19:35:34 (13 years ago)
Author:
Eoin
Message:

ListView? sorting working but not complete.

Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/HaliteListView.cpp

    r241 r243  
    55 
    66HaliteListViewCtrl::HaliteListViewCtrl(HaliteWindow& HalWindow) : 
     7        halWindow_(HalWindow), 
    78        iniClass("listviews/halite", "HaliteListView") 
    89{                
    910        HalWindow.connectUiUpdate(bind(&HaliteListViewCtrl::uiUpdate, this, _1)); 
    1011        load(); 
     12         
     13        adapters_.push_back(new Adapters::Filename()); 
     14        adapters_.push_back(new Adapters::State()); 
     15        adapters_.push_back(new Adapters::Tracker()); 
    1116} 
    1217         
     
    1419{ 
    1520        SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    16  
     21        SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
     22         
    1723        SetListViewDetails(); 
    1824} 
     
    2935} 
    3036 
    31  
    3237void HaliteListViewCtrl::uiUpdate(const hal::TorrentDetails& tD) 
    3338{ 
     
    3641        UpdateLock<listClass> rLock(*this); 
    3742         
    38         tD.sort(hal::TorrentDetails::name); 
    39         DeleteAllItems(); 
     43        tD.sort(bind(&Adapter::less, &adapters_[1], _1, _2)); 
     44         
     45//      DeleteAllItems(); 
    4046         
    4147        foreach (const hal::TorrentDetail_ptr td, tD.torrents())  
     
    7985        } 
    8086 
    81         manager_.sync_list(false, false); 
    82 //      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, L"Two: Sync"))); 
     87//      manager_.sync_list(false, false); 
    8388        } 
     89} 
     90 
     91int HaliteListViewCtrl::CompareItemsCustom(LVCompareParam* pItem1, LVCompareParam* pItem2, int iSortCol) 
     92{        
     93        boost::array<wchar_t, MAX_PATH> buffer; 
     94         
     95        GetItemText(pItem1->iItem, 0, buffer.c_array(), buffer.size());          
     96        wstring torrent1 = buffer.data(); 
     97         
     98        GetItemText(pItem2->iItem, 0, buffer.c_array(), buffer.size());          
     99        wstring torrent2 = buffer.data(); 
     100                 
     101        bool less = adapters_[1].less(halWindow_.torrents().get(torrent1), halWindow_.torrents().get(torrent2)); 
     102                 
     103        return (less) ? 1 : -1; 
    84104} 
    85105 
     
    87107{ 
    88108        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    89                 bind(&hal::BitTorrent::resumeTorrent, &hal::bittorrent(), _1)); 
     109                bind(&hal::BitTorrent::resumeTorrent, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
    90110         
    91111        return 0; 
     
    95115{ 
    96116        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    97                 bind(&hal::BitTorrent::pauseTorrent, &hal::bittorrent(), _1)); 
     117                bind(&hal::BitTorrent::pauseTorrent, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
    98118         
    99119        return 0; 
     
    103123{ 
    104124        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    105                 bind(&hal::BitTorrent::stopTorrent, &hal::bittorrent(), _1)); 
     125                bind(&hal::BitTorrent::stopTorrent, &hal::bittorrent(),bind(&hal::to_utf8, _1))); 
    106126         
    107127        return 0; 
     
    110130LRESULT HaliteListViewCtrl::OnRemoveFocused(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    111131{ 
    112         hal::bittorrent().removeTorrent(manager_.selected()); 
     132        hal::bittorrent().removeTorrent(hal::to_utf8(manager_.selected())); 
    113133 
    114134        clearFocused();  
     
    119139{ 
    120140        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    121                 bind(&hal::BitTorrent::removeTorrent, &hal::bittorrent(), _1)); 
     141                bind(&hal::BitTorrent::removeTorrent, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
    122142 
    123143        clearSelected();         
     
    128148{ 
    129149        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    130                 bind(&hal::BitTorrent::removeTorrentWipeFiles, &hal::bittorrent(), _1)); 
     150                bind(&hal::BitTorrent::removeTorrentWipeFiles, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
    131151         
    132152        clearSelected(); 
  • src/HaliteListView.hpp

    r241 r243  
    1616 
    1717class HaliteListViewCtrl : 
    18         public CHaliteListViewCtrl2<HaliteListViewCtrl>, 
     18        public CHaliteListViewCtrl2<HaliteListViewCtrl, const hal::TorrentDetail_ptr>, 
    1919        public CHaliteIni<HaliteListViewCtrl>, 
    2020        private boost::noncopyable 
     
    2222protected: 
    2323        typedef CHaliteIni<HaliteListViewCtrl> iniClass; 
    24         typedef CHaliteListViewCtrl2<HaliteListViewCtrl> listClass; 
     24        typedef CHaliteListViewCtrl2<HaliteListViewCtrl, const hal::TorrentDetail_ptr> listClass; 
    2525 
    2626        friend class listClass; 
     27         
     28        class Adapters 
     29        { 
     30         
     31        typedef const hal::TorrentDetail_ptr tD; 
     32        typedef HaliteListViewCtrl::Adapter adpt; 
     33         
     34        class Filename : public adpt 
     35        {        
     36        public: 
     37                virtual bool less(tD& l, tD& r) 
     38                { 
     39                        return l->filename() < r->filename(); 
     40                } 
     41                 
     42                virtual std::wstring print(tD& t) 
     43                { 
     44                        return t->filename(); 
     45                }                
     46        }; 
     47         
     48        class State : public adpt 
     49        {        
     50        public: 
     51                virtual bool less(tD& l, tD& r) 
     52                { 
     53                        return l->state() < r->state(); 
     54                } 
     55                 
     56                virtual std::wstring print(tD& t) 
     57                { 
     58                        return t->state(); 
     59                }                
     60        }; 
     61         
     62        class Tracker : public adpt 
     63        {        
     64        public: 
     65                virtual bool less(tD& l, tD& r) 
     66                { 
     67                        return l->currentTracker() < r->currentTracker(); 
     68                } 
     69                 
     70                virtual std::wstring print(tD& t) 
     71                { 
     72                        return t->currentTracker(); 
     73                }                
     74        }; 
     75         
     76        }; 
    2777 
    2878public: 
     
    67117                ar & boost::serialization::make_nvp("listview", boost::serialization::base_object<listClass>(*this)); 
    68118    } 
     119                 
     120        int CompareItemsCustom(LVCompareParam* /*pItem1*/, LVCompareParam* /*pItem2*/, int /*iSortCol*/); 
     121 
    69122                                 
    70123private: 
    71124        void OnAttach(); 
    72125        void OnDetach(); 
     126         
     127        HaliteWindow& halWindow_; 
    73128}; 
    74129 
    75 typedef HaliteListViewCtrl::selection_manage_class ListViewManager; 
     130typedef HaliteListViewCtrl::SelectionManager ListViewManager; 
  • src/HaliteListViewCtrl2.hpp

    r241 r243  
    77#include <boost/serialization/vector.hpp> 
    88#include <boost/serialization/split_free.hpp> 
     9#include <boost/ptr_container/ptr_vector.hpp> 
    910 
    1011#include "stdAfx.hpp" 
     
    3839}; 
    3940 
    40 template <class TBase> 
    41 class CHaliteListViewCtrl2 : public CWindowImpl<TBase, CListViewCtrl> 
     41template <class TBase, typename adapterType, size_t N=-1> 
     42class CHaliteListViewCtrl2 :  
     43        public CSortListViewCtrlImpl<CHaliteListViewCtrl2<TBase, adapterType, N> > 
    4244{ 
    4345public: 
    44         typedef CHaliteListViewCtrl2<TBase> thisClass; 
    45          
    46         template <typename L, typename S=std::string> 
     46        typedef CHaliteListViewCtrl2<TBase, adapterType, N> thisClass; 
     47        typedef CSortListViewCtrlImpl<thisClass> parentClass; 
     48         
    4749        class selection_manager :  
    4850                private boost::noncopyable 
    4951        {        
    5052        public: 
    51                 selection_manager(L& m_list) : 
     53                selection_manager(thisClass& m_list) : 
    5254                        m_list_(m_list) 
    5355                {} 
    5456                 
    55                 typedef const S& param_type; 
     57                typedef std::wstring string_t;  
     58                typedef const string_t& param_type; 
    5659                 
    5760                void sync_list(bool list_to_manager, bool signal_change=true) 
    5861                { 
    59 //                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"  A: %1%, %2% %3%") % hal::from_utf8(selected_) % list_to_manager % signal_change).str().c_str()))); 
    60  
    6162                        if (list_to_manager) 
    6263                        {        
     
    6768                                if (managerToList() && signal_change) signal(); 
    6869                        } 
    69                          
    70 //                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"  Z: %1%, %2% %3%") % hal::from_utf8(selected_) % list_to_manager % signal_change).str().c_str()))); 
    7170                } 
    7271                 
     
    7473                { 
    7574                        boost::array<wchar_t, MAX_PATH> pathBuffer; 
    76                         std::set<S> all_selected; 
    77                         string selected = ""; 
     75                        std::set<string_t> all_selected; 
     76                        string_t selected = L""; 
    7877                         
    7978                        bool do_signal = false; 
     
    8887                                { 
    8988                                        m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size());      
    90                                         all_selected.insert(hal::to_utf8(pathBuffer.data())); 
     89                                        all_selected.insert(pathBuffer.data()); 
    9190                                } 
    9291                                if (flags && LVIS_FOCUSED) 
    9392                                { 
    94                                         selected = hal::to_utf8(pathBuffer.data()); 
     93                                        selected = pathBuffer.data(); 
    9594                                } 
    9695                        } 
     
    114113                { 
    115114                        // Prevent changing states from signaling another sync 
    116                         UpdateLock<L> lock(m_list_); 
     115                        UpdateLock<thisClass> lock(m_list_); 
    117116                         
    118117                        boost::array<wchar_t, MAX_PATH> pathBuffer; 
     
    127126                        { 
    128127                                m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size()); 
    129                                 string temp_name = hal::to_utf8(pathBuffer.data()); 
     128                                string_t temp_name = pathBuffer.data(); 
    130129                                 
    131130                                LVITEM lvi = { LVIF_STATE }; 
     
    148147                } 
    149148                 
    150                 int selectMatch(const string& name) 
     149                int selectMatch(const string_t& name) 
    151150                { 
    152151                        LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };  
    153152                        findInfo.flags = LVFI_STRING; 
    154                          
    155                         wstring torrent_name = hal::from_utf8(name);             
    156                         findInfo.psz = torrent_name.c_str(); 
     153                                         
     154                        findInfo.psz = name.c_str(); 
    157155                         
    158156                        int itemPos = m_list_.FindItem(&findInfo, -1);   
    159                          
    160 //                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"Two: %1%, %2%") % torrent_name % itemPos).str().c_str()))); 
    161                          
     157                                                 
    162158                        if (itemPos == -1) 
    163159                                return itemPos; 
     
    180176                int selectedIndex() 
    181177                { 
    182                         wstring torrent_name = hal::from_utf8(selected_);        
    183178                        LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };          
    184                         findInfo.psz = torrent_name.c_str(); 
     179                        findInfo.psz = selected_.c_str(); 
    185180                         
    186181                        return m_list_.FindItem(&findInfo, -1);          
    187182                } 
    188183                 
    189                 const std::set<string>& allSelected() const { return all_selected_; } 
    190                  
    191                 void setSelected(const string& sel)  
     184                const std::set<string_t>& allSelected() const { return all_selected_; } 
     185                 
     186                void setSelected(const string_t& sel)  
    192187                { 
    193188                        selected_ = sel; 
    194                 //      sync_list(false); 
    195189                } 
    196190                 
     
    212206                { 
    213207                        // Prevent changing states from signaling another sync 
    214                         UpdateLock<L> lock(m_list_); 
    215                          
    216                         hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"Clear")).str().c_str()))); 
     208                        UpdateLock<thisClass> lock(m_list_); 
     209                         
     210//                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"Clear")).str().c_str()))); 
    217211         
    218212                        m_list_.DeleteItem(selectedIndex()); 
    219213                         
    220                 //      m_list_.SelectItem(0); 
    221214                        sync_list(true);         
    222215                } 
     
    225218                { 
    226219                        // Prevent changing states from signaling another sync 
    227                         UpdateLock<L> lock(m_list_); 
    228                          
    229                         hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"ClearAllSelected")).str().c_str()))); 
     220                        UpdateLock<thisClass> lock(m_list_); 
     221                         
     222//                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"ClearAllSelected")).str().c_str()))); 
    230223 
    231224                        int total = m_list_.GetItemCount(); 
     
    240233                        all_selected_.clear(); 
    241234                         
    242                 //      m_list_.SelectItem(0); 
    243235                        sync_list(true);         
    244236                } 
     
    247239                { 
    248240                        // Prevent changing states from signaling another sync 
    249                         UpdateLock<L> lock(m_list_); 
    250                          
    251                         hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"ClearAll")).str().c_str()))); 
     241                        UpdateLock<thisClass> lock(m_list_); 
     242                         
     243//                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"ClearAll")).str().c_str()))); 
    252244 
    253245                        m_list_.DeleteAllItems(); 
     
    265257                 
    266258        private: 
    267                 S selected_; 
    268                 std::set<S> all_selected_; 
     259                string_t selected_; 
     260                std::set<string_t> all_selected_; 
    269261                 
    270262                mutable boost::signal<void (param_type)> selection_; 
    271                 L& m_list_; 
     263                thisClass& m_list_; 
    272264        }; 
    273265         
     
    309301                WTL::CMenu menu_; 
    310302        }; 
     303         
     304        class Adapter 
     305        { 
     306        public: 
     307                virtual bool less(adapterType& l, adapterType& r) = 0; 
     308                virtual std::wstring print(adapterType& t) = 0; 
     309        }; 
    311310 
    312311public: 
    313         typedef selection_manager<thisClass> selection_manage_class; 
    314          
    315         enum sortDirection 
    316         { 
    317                 none, 
    318                 ascending, 
    319                 descending 
    320         }; 
    321          
    322         CHaliteListViewCtrl2<TBase>() : 
    323                 sortingDirection_(CHaliteListViewCtrl2<TBase>::none), 
    324                 sortedColmun_(0), 
     312        typedef selection_manager SelectionManager; 
     313        typedef SelectionManager selection_manager_class; 
     314         
     315        thisClass() : 
    325316                manager_(*this), 
    326317                updateLock_(0) 
     
    349340        } 
    350341 
    351         BEGIN_MSG_MAP_EX(CHaliteListViewCtrl2<TBase>) 
     342        BEGIN_MSG_MAP_EX(thisClass) 
    352343                REFLECTED_NOTIFY_CODE_HANDLER(NM_CLICK, OnClick) 
    353344                REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick) 
    354345                REFLECTED_NOTIFY_CODE_HANDLER(LVN_ITEMCHANGED, OnItemChanged) 
    355                 REFLECTED_NOTIFY_CODE_HANDLER(LVN_COLUMNCLICK , OnColClick) 
     346        //      REFLECTED_NOTIFY_CODE_HANDLER(LVN_COLUMNCLICK , OnColClick) 
    356347 
    357348                DEFAULT_REFLECTION_HANDLER() 
     349                CHAIN_MSG_MAP(parentClass) 
    358350        END_MSG_MAP() 
    359351 
     
    361353        { 
    362354                ATLASSERT(::IsWindow(hWndNew)); 
    363         CWindowImpl<TBase, CListViewCtrl>::SubclassWindow(hWndNew); 
     355        parentClass::SubclassWindow(hWndNew); 
    364356 
    365357                TBase* pT = static_cast<TBase*>(this); 
     
    376368                foreach (wstring name, names_) 
    377369                { 
    378                         AddColumn(name.c_str(), header_.GetItemCount()); 
     370                        int i = header_.GetItemCount(); 
     371                         
     372                        AddColumn(name.c_str(), i); 
     373                        SetColumnSortType(i, LVCOLSORT_CUSTOM); 
    379374                }                
    380375 
     
    426421        } 
    427422 
    428  
    429423        LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&) 
    430424        { 
     
    453447                MessageBox((lexical_cast<wstring>(pnlv->iSubItem)).c_str(), L"Hi", 0); 
    454448                return 0; 
     449        } 
     450                 
     451        int CompareItemsCustom(LVCompareParam* pItem1, LVCompareParam* pItem2, int iSortCol) 
     452        { 
     453                TBase* pT = static_cast<TBase*>(this); 
     454                return pT->CompareItemsCustom(pItem1, pItem2, iSortCol); 
    455455        } 
    456456         
     
    463463    } 
    464464 
    465         const selection_manager<CHaliteListViewCtrl2>& manager() { return manager_; } 
    466          
    467         size_t sortedColmun() { return sortedColmun_; } 
    468         sortDirection sortingDirection() { return sortingDirection_; } 
    469          
     465        const SelectionManager& manager() { return manager_; } 
     466                 
    470467        std::vector<int>& listColumnWidth() { return listColumnWidth_; } 
    471468        std::vector<int>& listColumnOrder() { return listColumnOrder_; } 
     
    481478 
    482479protected: 
    483         selection_manager<CHaliteListViewCtrl2> manager_; 
     480        SelectionManager manager_; 
     481        boost::ptr_vector<Adapter> adapters_; 
    484482         
    485483private: 
     
    498496                }                
    499497        } 
    500          
    501         sortDirection sortingDirection_; 
    502         size_t sortedColmun_; 
    503          
     498                 
    504499        WTL::CMenu menu_; 
    505500        CHaliteHeaderCtrl header_; 
  • src/HaliteWindow.cpp

    r241 r243  
    237237 
    238238void HaliteWindow::issueUiUpdate() 
    239 { 
     239{        
     240//      hal::event().post(shared_ptr<hal::EventDetail>( 
     241//              new hal::EventDebug(hal::Event::info, (wformat(L"issueUiUpdate")).str().c_str()))); 
     242 
    240243        try 
    241244        { 
     245         
     246        std::set<string> allSelected; 
     247 
     248        std::transform(haliteList.manager().allSelected().begin(),  
     249                                   haliteList.manager().allSelected().end(),  
     250                                   std::inserter(allSelected, allSelected.end()),  
     251                                   &hal::to_utf8);       
    242252 
    243253        torrents_ = hal::bittorrent().getTorrentDetails( 
    244                 haliteList.manager().selected(), haliteList.manager().allSelected()); 
     254                hal::to_utf8(haliteList.manager().selected()), allSelected); 
    245255 
    246256        ui_update_signal_(torrents()); 
  • src/advtabs/Peers.hpp

    r240 r243  
    1313 
    1414class PeerListViewCtrl : 
    15         public CHaliteListViewCtrl<PeerListViewCtrl>, 
     15        public CHaliteListViewCtrl2<PeerListViewCtrl, int>, 
    1616        public CHaliteIni<PeerListViewCtrl>, 
    1717        private boost::noncopyable 
     
    1919        typedef PeerListViewCtrl thisClass; 
    2020        typedef CHaliteIni<thisClass> iniClass; 
    21         typedef CHaliteListViewCtrl<thisClass> listClass; 
     21        typedef CHaliteListViewCtrl2<thisClass, int> listClass; 
    2222 
    2323        friend class listClass; 
  • src/halTorrent.cpp

    r237 r243  
    257257{ 
    258258        std::stable_sort(torrents_.begin(), torrents_.end(), &nameLess); 
     259} 
     260 
     261void TorrentDetails::sort( 
     262        boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const 
     263{ 
     264        std::stable_sort(torrents_.begin(), torrents_.end(), fn); 
    259265} 
    260266 
     
    976982        torrentsContainer.reserve(pimpl->torrents.size()); 
    977983         
    978         foreach (TorrentPair t, pimpl->torrents) 
    979         { 
    980                 torrentsContainer.push_back(t.second.getTorrentDetail_ptr()); 
     984        for (TorrentMap::const_iterator i=pimpl->torrents.begin(), e=pimpl->torrents.end(); i != e; ++i) 
     985        { 
     986                torrentsContainer.push_back((*i).second.getTorrentDetail_ptr()); 
    981987        } 
    982988         
     
    10071013        torrentDetails.torrents_.reserve(pimpl->torrents.size()); 
    10081014         
    1009         foreach (TorrentPair t, pimpl->torrents) 
    1010         { 
    1011                 if (allSelected.find(hal::to_utf8(t.second.filename())) != allSelected.end()) 
     1015        for (TorrentMap::const_iterator i=pimpl->torrents.begin(), e=pimpl->torrents.end(); i != e; ++i) 
     1016        {        
     1017                TorrentDetail_ptr pT = (*i).second.getTorrentDetail_ptr(); 
     1018                 
     1019                if (allSelected.find(hal::to_utf8((*i).second.filename())) != allSelected.end()) 
    10121020                { 
    1013                         torrentDetails.selectedTorrents_.push_back(t.second.getTorrentDetail_ptr()); 
    1014                 } 
    1015                  
    1016                 if (selected == hal::to_utf8(t.second.filename())) 
    1017                         torrentDetails.selectedTorrent_ = t.second.getTorrentDetail_ptr(); 
    1018                  
    1019                 torrentDetails.torrents_.push_back(t.second.getTorrentDetail_ptr()); 
     1021                        torrentDetails.selectedTorrents_.push_back(pT); 
     1022                } 
     1023                 
     1024                if (selected == hal::to_utf8((*i).second.filename())) 
     1025                        torrentDetails.selectedTorrent_ = pT; 
     1026                 
     1027                torrentDetails.torrentMap_[(*i).second.filename()] = pT; 
     1028                torrentDetails.torrents_.push_back(pT); 
    10201029        } 
    10211030         
     
    10811090                create_directory(resumeDir); 
    10821091         
    1083         foreach (TorrentPair t, pimpl->torrents) 
    1084         { 
    1085                 t.second.handle().pause(); // NB. internal pause, not registered in Torrents.xml 
    1086                 lbt::entry resumedata = t.second.handle().write_resume_data(); 
    1087                 pimpl->theSession.remove_torrent(t.second.handle()); 
    1088                  
    1089                 bool halencode_result = halencode(resumeDir/from_utf8(t.first), resumedata); 
     1092        for (TorrentMap::const_iterator i=pimpl->torrents.begin(), e=pimpl->torrents.end(); i != e; ++i) 
     1093        { 
     1094                (*i).second.handle().pause(); // NB. internal pause, not registered in Torrents.xml 
     1095                lbt::entry resumedata = (*i).second.handle().write_resume_data(); 
     1096                pimpl->theSession.remove_torrent((*i).second.handle()); 
     1097                 
     1098                bool halencode_result = halencode(resumeDir/from_utf8((*i).first), resumedata); 
    10901099                assert(halencode_result); 
    10911100        } 
  • src/halTorrent.hpp

    r237 r243  
    6868public: 
    6969        TorrentDetail(std::wstring f, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
    70                         float c=0, float d=0, boost::int64_t tWD=0, boost::int64_t tW=0, boost::int64_t tU=0, int p=0, int sd=0, float r=0,  
     70                        float c=0, float d=0, boost::int64_t tWD=0, boost::int64_t tW=0, boost::int64_t tU=0, boost::int64_t tpU=0, boost::int64_t tD=0, boost::int64_t tpD=0, int p=0, int sd=0, float r=0,  
    7171                        time_duration eta=boost::posix_time::seconds(0), time_duration uIn=boost::posix_time::seconds(0)) : 
    7272                filename_(f), 
     
    7979                totalWanted_(tW), 
    8080                totalUploaded_(tU), 
     81                totalPayloadUploaded_(tpU), 
     82                totalDownloaded_(tD), 
     83                totalPayloadDownloaded_(tpD), 
    8184                peers_(p), 
    8285                seeds_(sd), 
     
    100103        const std::wstring& filename() const { return filename_; } 
    101104        const std::wstring& state() const { return state_; } 
    102         const std::wstring& currentTracker() { return currentTracker_; } 
     105        const std::wstring& currentTracker() const { return currentTracker_; } 
    103106         
    104107        std::pair<float,float> speed() const { return speed_; } 
     
    132135        boost::int64_t totalWanted_; 
    133136        boost::int64_t totalUploaded_; 
     137        boost::int64_t totalPayloadUploaded_; 
     138        boost::int64_t totalDownloaded_; 
     139        boost::int64_t totalPayloadDownloaded_; 
    134140         
    135141        int peers_; 
     
    148154typedef shared_ptr<TorrentDetail> TorrentDetail_ptr; 
    149155typedef std::vector<TorrentDetail_ptr> TorrentDetail_vec; 
     156typedef std::map<std::wstring, TorrentDetail_ptr> TorrentDetail_map; 
    150157 
    151158class TorrentDetails 
     
    166173         
    167174        void sort(sortIndex i) const; 
     175        void sort(boost::function<bool (const TorrentDetail_ptr&, const TorrentDetail_ptr&)> fn) const; 
    168176         
    169177        const TorrentDetail_vec torrents() const { return torrents_; } 
     
    171179        const TorrentDetail_ptr selectedTorrent() const { return selectedTorrent_; } 
    172180         
     181        const TorrentDetail_ptr get(std::wstring filename) const 
     182        { 
     183                TorrentDetail_map::const_iterator i = torrentMap_.find(filename); 
     184                 
     185                if (i != torrentMap_.end()) 
     186                { 
     187                        return i->second; 
     188                } 
     189                 
     190                return TorrentDetail_ptr(); 
     191        } 
     192         
    173193        friend class BitTorrent; 
    174194 
    175195private: 
    176196        mutable TorrentDetail_vec torrents_; 
     197        TorrentDetail_map torrentMap_; 
    177198        TorrentDetail_vec selectedTorrents_; 
    178199        TorrentDetail_ptr selectedTorrent_; 
  • src/halTorrentInternal.hpp

    r236 r243  
    77} 
    88 
    9 BOOST_CLASS_VERSION(hal::TorrentInternal, 3) 
     9BOOST_CLASS_VERSION(hal::TorrentInternal, 4) 
    1010 
    1111namespace hal  
     
    2323{ 
    2424        friend class BitTorrent_impl; 
     25         
     26        template<typename T> 
     27        class TransferTracker 
     28        { 
     29        public: 
     30                TransferTracker() : 
     31                        total_(0), 
     32                        total_offset_(0) 
     33                {} 
     34                 
     35                TransferTracker(T total) : 
     36                        total_(total), 
     37                        total_offset_(0) 
     38                {} 
     39                 
     40                void reset(T total) const 
     41                { 
     42                        total_ = total; 
     43                        total_offset_ = 0; 
     44                } 
     45                 
     46                T update(T rel_total) const 
     47                { 
     48                        total_ += (rel_total - total_offset_); 
     49                        total_offset_ = rel_total; 
     50                                                 
     51                        return total_; 
     52                } 
     53                 
     54                operator T() const { return total_; } 
     55                 
     56                friend class boost::serialization::access; 
     57                template<class Archive> 
     58                void serialize(Archive& ar, const unsigned int version) 
     59                { 
     60                        ar & make_nvp("total", total_); 
     61                } 
     62                 
     63        private: 
     64                mutable T total_; 
     65                mutable T total_offset_; 
     66        }; 
    2567         
    2668public: 
     
    150192        }        
    151193         
    152         pair<wstring, wstring> getTrackerLogin() 
     194        pair<wstring, wstring> getTrackerLogin() const 
    153195        { 
    154196                return make_pair(trackerUsername_, trackerPassword_); 
    155197        } 
    156198         
    157         std::wstring filename() { return filename_; } 
     199        const std::wstring& filename() const { return filename_; } 
    158200         
    159201        const libtorrent::torrent_handle& handle() const { return handle_; } 
     
    226268        ar & make_nvp("saveDirectory", save_directory_); 
    227269                 
     270                if (version > 3) { 
     271                        ar & make_nvp("payloadUploaded_", payloadUploaded_); 
     272                        ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
     273                        ar & make_nvp("uploaded_", uploaded_); 
     274                        ar & make_nvp("downloaded_", downloaded_);               
     275                }  
     276                else if (version > 1) 
     277                { 
     278                        ar & make_nvp("totalUploaded", totalUploaded_); 
     279                        ar & make_nvp("ratio", ratio_); 
     280                         
     281                        payloadUploaded_.reset(totalUploaded_); 
     282                } 
     283                 
    228284                if (version > 0) { 
    229285                        ar & make_nvp("trackerUsername", trackerUsername_); 
     
    233289                        ar & make_nvp("state", state_); 
    234290                        ar & make_nvp("trackers", trackers_); 
    235                         ar & make_nvp("totalUploaded", totalUploaded_); 
    236                         ar & make_nvp("ratio", ratio_); 
    237                 }                
     291                } 
     292         
    238293                if (version > 2) { 
    239294                        ar & make_nvp("resolve_countries", resolve_countries_); 
     
    295350        mutable boost::int64_t totalBase_; 
    296351         
     352        TransferTracker<boost::int64_t> payloadUploaded_; 
     353        TransferTracker<boost::int64_t> payloadDownloaded_; 
     354        TransferTracker<boost::int64_t> uploaded_; 
     355        TransferTracker<boost::int64_t> downloaded_; 
     356         
    297357        std::vector<TrackerDetail> trackers_; 
    298358        std::vector<lbt::announce_entry> torrent_trackers_; 
     
    346406 
    347407TorrentDetail_ptr TorrentInternal::getTorrentDetail_ptr() const 
    348 { 
     408{        
    349409        if (inSession()) 
    350410        { 
     
    397457                totalUploaded_ += (tS.total_payload_upload - totalBase_); 
    398458                totalBase_ = tS.total_payload_upload; 
     459                 
     460                uploaded_.update(tS.total_upload); 
     461                payloadUploaded_.update(tS.total_payload_upload); 
     462                downloaded_.update(tS.total_download); 
     463                payloadDownloaded_.update(tS.total_payload_download); 
    399464 
    400465                return TorrentDetail_ptr(new TorrentDetail(filename_, state, hal::from_utf8(tS.current_tracker),  
    401466                        pair<float, float>(tS.download_payload_rate, tS.upload_payload_rate), 
    402                         tS.progress, tS.distributed_copies, tS.total_wanted_done, tS.total_wanted, totalUploaded_, 
    403                         tS.num_peers, tS.num_seeds, ratio_, td, tS.next_announce)); 
     467                        tS.progress, tS.distributed_copies, tS.total_wanted_done, tS.total_wanted, uploaded_, payloadUploaded_, 
     468                        downloaded_, payloadDownloaded_, tS.num_peers, tS.num_seeds, ratio_, td, tS.next_announce)); 
    404469        } 
    405470        else 
Note: See TracChangeset for help on using the changeset viewer.