Changeset 291


Ignore:
Timestamp:
09/14/07 20:29:43 (13 years ago)
Author:
Eoin
Message:

Still borked but not so much.

Files:
11 edited

Legend:

Unmodified
Added
Removed
  • Jamfile.v2

    r285 r291  
    66 
    77SOURCES = 
     8        halTorrent.cpp 
    89        global/logger.cpp 
    9         global/string_conv.cpp 
     10#       global/string_conv.cpp 
    1011        global/wtl_app.cpp 
    1112        global/ini.cpp 
     
    2324        ConfigOptions.cpp 
    2425        halConfig.cpp 
    25         halTorrent.cpp 
    2626        halEvent.cpp 
    2727#       halXmlRpc.cpp 
  • src/ConfigOptions.hpp

    r290 r291  
    475475                 
    476476                string rtf(static_cast<char*>(res.first), res.second);           
    477                 wstring wrtf = hal::safe_from_utf8(rtf); 
     477                wstring wrtf = hal::from_utf8_safe(rtf); 
    478478                 
    479479                richEdit_.SendMessage(WM_SETTEXT, 0, (LPARAM)wrtf.c_str());              
  • src/HaliteDialog.cpp

    r285 r291  
    234234        if (hal::TorrentDetail_ptr torrent = tD.selectedTorrent())       
    235235        {        
    236                 string torrent_name = hal::to_utf8(torrent->filename()); 
     236                string torrent_name = hal::to_utf8(torrent->name()); 
    237237                 
    238238                if (current_torrent_name_ != torrent_name) 
     
    242242                }        
    243243                 
    244                 SetDlgItemText(IDC_NAME, torrent->filename().c_str()); 
     244                SetDlgItemText(IDC_NAME, torrent->name().c_str()); 
    245245                SetDlgItemText(IDC_TRACKER, torrent->currentTracker().c_str()); 
    246246                SetDlgItemText(IDC_STATUS, torrent->state().c_str()); 
  • src/HaliteListView.cpp

    r282 r291  
    3737        ApplyDetails(); 
    3838         
    39         SetColumnSortType(0, LVCOLSORT_CUSTOM, new ColumnAdapters::Filename()); 
     39        SetColumnSortType(0, LVCOLSORT_CUSTOM, new ColumnAdapters::Name()); 
    4040        SetColumnSortType(1, LVCOLSORT_CUSTOM, new ColumnAdapters::State()); 
    4141        SetColumnSortType(2, LVCOLSORT_CUSTOM, new ColumnAdapters::Progress()); 
     
    111111{ 
    112112        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    113                 bind(&hal::BitTorrent::resumeTorrent, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
     113                bind((void (hal::BitTorrent::*)(const std::wstring&))&hal::BitTorrent::resumeTorrent,  
     114                        &hal::bittorrent(), _1)); 
    114115         
    115116        return 0; 
     
    117118 
    118119LRESULT HaliteListViewCtrl::OnPause(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    119 { 
     120{        
    120121        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    121                 bind(&hal::BitTorrent::pauseTorrent, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
     122                bind((void (hal::BitTorrent::*)(const std::wstring&))&hal::BitTorrent::pauseTorrent, 
     123                        &hal::bittorrent(), _1)); 
    122124         
    123125        return 0; 
     
    127129{ 
    128130        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    129                 bind(&hal::BitTorrent::stopTorrent, &hal::bittorrent(),bind(&hal::to_utf8, _1))); 
     131                bind((void (hal::BitTorrent::*)(const std::wstring&))&hal::BitTorrent::stopTorrent,  
     132                        &hal::bittorrent(), _1)); 
    130133         
    131134        return 0; 
     
    143146{ 
    144147        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    145                 bind(&hal::BitTorrent::removeTorrent, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
     148                bind((void (hal::BitTorrent::*)(const std::wstring&))&hal::BitTorrent::removeTorrent,  
     149                        &hal::bittorrent(), _1)); 
    146150 
    147151        clearSelected();         
     
    152156{ 
    153157        std::for_each(manager().allSelected().begin(), manager().allSelected().end(), 
    154                 bind(&hal::BitTorrent::removeTorrentWipeFiles, &hal::bittorrent(), bind(&hal::to_utf8, _1))); 
     158                bind((void (hal::BitTorrent::*)(const std::wstring&))&hal::BitTorrent::removeTorrentWipeFiles,  
     159                        &hal::bittorrent(), _1)); 
    155160         
    156161        clearSelected(); 
  • src/HaliteListView.hpp

    r282 r291  
    3737        typedef listClass::ColumnAdapter ColAdapter_t; 
    3838         
     39        struct Name : public ColAdapter_t 
     40        {        
     41                virtual bool less(tD& l, tD& r) { return l->name() < r->name(); }                
     42                virtual std::wstring print(tD& t) { return t->name(); }          
     43        }; 
     44         
    3945        struct Filename : public ColAdapter_t 
    4046        {        
  • src/HaliteWindow.cpp

    r290 r291  
    250250        { 
    251251         
    252         std::set<string> allSelected; 
     252/*      std::set<string> allSelected; 
    253253 
    254254        std::transform(haliteList.manager().allSelected().begin(),  
     
    256256                                   std::inserter(allSelected, allSelected.end()),  
    257257                                   &hal::to_utf8);       
    258  
     258*/ 
    259259        const hal::TorrentDetails& torrents = hal::bittorrent().updateTorrentDetails( 
    260                 hal::to_utf8(haliteList.manager().selected()), allSelected); 
     260                haliteList.manager().selected(), haliteList.manager().allSelected()); 
    261261 
    262262        ui_update_signal_(torrents); 
  • src/global/string_conv.hpp

    r268 r291  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2007. 
     2// Copyright (c) 2007 Eóin O'Callaghan 
     3// 
    34// Distributed under the Boost Software License, Version 1.0. 
    4 //    (See accompanying file LICENSE_1_0.txt or copy at 
    5 //          http://www.boost.org/LICENSE_1_0.txt) 
     5// http://www.boost.org/LICENSE_1_0.txt 
    66 
    77#ifndef GLOBAL_STRING_CONV 
     
    1010#include <string> 
    1111#include <boost/array.hpp> 
     12#include "unicode.hpp" 
    1213 
    1314namespace hal 
    1415{ 
    1516 
    16 std::wstring mbstowcs(const std::string& ustr); 
    17 std::string wcstombs(const std::wstring& wstr); 
     17inline std::string to_utf8(const std::wstring& wstr)  
     18{  
     19        std::string ustr; 
    1820 
    19 inline std::string wstr_to_str(const std::wstring& wstr)  
    20 {                
    21         std::string str; 
    22         str.reserve(wstr.length()); 
    23          
    24         for (std::string::const_iterator i=str.begin(); i!=str.end(); ++i) 
    25         { 
    26                 wchar_t wide_char = *i; 
    27                 char narrow_char = 0; 
    28                  
    29                 narrow_char = *(reinterpret_cast<char*>(&wide_char)); 
    30                 str.push_back(narrow_char); 
    31         } 
    32          
    33         return str; 
     21        unicode::transcode<unicode::wchar_encoding, unicode::utf8>( 
     22           wstr.begin(), 
     23           wstr.end(), 
     24           std::insert_iterator<std::string>(ustr, ustr.end()) 
     25        ); 
     26 
     27        return ustr; 
    3428} 
    3529 
    36 inline std::string to_utf8(const std::wstring& str)  
     30inline std::wstring from_utf8(const std::string& ustr)  
    3731{  
    38         return wcstombs(str);  
     32        std::wstring wstr; 
     33         
     34        unicode::transcode<unicode::utf8, unicode::wchar_encoding>( 
     35           ustr.begin(), 
     36           ustr.end(), 
     37           std::insert_iterator<std::wstring>(wstr, wstr.end()) 
     38        ); 
     39 
     40        return wstr;  
    3941} 
    4042 
    41 inline std::wstring str_to_wstr(const std::string& str)  
    42 {                
    43         std::wstring wstr; 
    44         wstr.reserve(str.length()); 
    45          
    46         for (std::string::const_iterator i=str.begin(); i!=str.end(); ++i) 
     43inline std::wstring from_ascii(const std::string& s) 
     44{ 
     45        std::wstring ret; 
     46 
     47        for (const char *i = &s[0], *end = &s[0] + s.size(); i < end;) 
    4748        { 
    48                 char narrow_char = *i; 
    49                 wchar_t wide_char = 0; 
    50                  
    51                 *(reinterpret_cast<char*>(&wide_char)) = narrow_char; 
    52                 wstr.push_back(wide_char); 
     49                wchar_t c = '.'; 
     50                int result = std::mbtowc(&c, i, end - i); 
     51                if (result > 0) i += result; 
     52                else ++i; 
     53                ret += c; 
    5354        } 
    54          
    55         return wstr; 
     55 
     56        return ret; 
    5657} 
    5758 
    58 inline std::wstring safe_from_utf8(const std::string& str)  
    59 {                
     59inline std::wstring from_utf8_safe(const std::string& s) 
     60{ 
    6061        try 
    6162        { 
    62          
    63         return mbstowcs(str);  
    64          
     63                return from_utf8(s); 
    6564        } 
    66         catch(...) 
     65        catch (std::exception&) 
    6766        { 
    68          
    69         std::wstring wstr; 
    70         wstr.reserve(str.length()); 
    71          
    72         for (std::string::const_iterator i=str.begin(); i!=str.end(); ++i) 
    73         { 
    74                 char narrow_char = *i; 
    75                 wchar_t wide_char = 0; 
    76                  
    77                 *(reinterpret_cast<char*>(&wide_char)) = narrow_char; 
    78                 wstr.push_back(wide_char); 
    79         } 
    80          
    81         return wstr; 
    82          
     67                return from_ascii(s); 
    8368        } 
    8469} 
    8570 
    86 inline std::wstring from_utf8(const std::string& str)  
    87 {  
    88         return mbstowcs(str);   
     71inline std::wstring to_wstr(const std::wstring& s) 
     72{ 
     73                return s; 
     74} 
     75 
     76inline std::wstring to_wstr(const std::string& s) 
     77{ 
     78                return from_utf8_safe(s); 
    8979} 
    9080 
  • src/halEvent.hpp

    r290 r291  
    172172{ 
    173173public: 
    174         EventInvalidTorrent(Event::eventLevel l, Event::codes code, std::string t, std::string f) : 
     174        template<typename t_str, typename f_str> 
     175        EventInvalidTorrent(Event::eventLevel l, Event::codes code, t_str t, f_str f) : 
    175176                EventDetail(l, boost::posix_time::second_clock::universal_time(), code), 
    176                 torrent_(hal::from_utf8(t)), 
    177                 function_(hal::from_utf8(f)) 
     177                torrent_(hal::to_wstr(t)), 
     178                function_(hal::to_wstr(f)) 
    178179        {} 
    179180         
     
    192193{ 
    193194public: 
    194         EventTorrentException(Event::eventLevel l, Event::codes code, std::string e, std::string t, std::string f) : 
     195        template<typename e_str, typename t_str, typename f_str> 
     196        EventTorrentException(Event::eventLevel l, Event::codes code, e_str e, t_str t, f_str f) : 
    195197                EventDetail(l, boost::posix_time::second_clock::universal_time(), code), 
    196                 torrent_(hal::from_utf8(t)), 
    197                 function_(hal::from_utf8(f)), 
    198                 exception_(hal::from_utf8(e)) 
     198                torrent_(hal::to_wstr(t)), 
     199                function_(hal::to_wstr(f)), 
     200                exception_(hal::to_wstr(e)) 
    199201        {} 
    200202         
  • src/halTorrent.cpp

    r290 r291  
    341341                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    342342                                        wformat(hal::app().res_wstr(HAL_PEERALERT)) 
    343                                                 % hal::safe_from_utf8(a.msg()) 
    344                                                 % hal::safe_from_utf8(a.ip.address().to_string())) 
     343                                                % hal::from_utf8_safe(a.msg()) 
     344                                                % hal::from_utf8_safe(a.ip.address().to_string())) 
    345345                        )       );                               
    346346                } 
     
    351351                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    352352                                        wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
    353                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name()) 
    354                                                 % hal::safe_from_utf8(a.ip.address().to_string())) 
     353                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name()) 
     354                                                % hal::from_utf8_safe(a.ip.address().to_string())) 
    355355                        )       );                               
    356356                } 
     
    361361                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    362362                                        wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
    363                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name()) 
     363                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name()) 
    364364                                                % a.piece_index) 
    365365                        )       );                               
     
    371371                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    372372                                        wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
    373                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name()) 
    374                                                 % hal::safe_from_utf8(a.url) 
    375                                                 % hal::safe_from_utf8(a.msg())) 
     373                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name()) 
     374                                                % hal::from_utf8_safe(a.url) 
     375                                                % hal::from_utf8_safe(a.msg())) 
    376376                        )       );                               
    377377                } 
     
    382382                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    383383                                        wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
    384                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name()) 
    385                                                 % hal::safe_from_utf8(a.msg())) 
     384                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name()) 
     385                                                % hal::from_utf8_safe(a.msg())) 
    386386                        )       );                               
    387387                } 
     
    392392                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    393393                                        wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT)) 
    394                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name())) 
     394                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name())) 
    395395                        )       );                               
    396396                } 
     
    401401                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    402402                                        wformat(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
    403                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name()) 
    404                                                 % hal::safe_from_utf8(a.msg()) 
     403                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name()) 
     404                                                % hal::from_utf8_safe(a.msg()) 
    405405                                                % a.times_in_row 
    406406                                                % a.status_code) 
     
    413413                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    414414                                        wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
    415                                                 % hal::safe_from_utf8(a.handle.get_torrent_info().name()) 
    416                                                 % hal::safe_from_utf8(a.msg()) 
     415                                                % hal::from_utf8_safe(a.handle.get_torrent_info().name()) 
     416                                                % hal::from_utf8_safe(a.msg()) 
    417417                                                % a.num_peers) 
    418418                        )       );                               
     
    423423                        event().post(shared_ptr<EventDetail>( 
    424424                                        new EventLibtorrent(lbtAlertToHalEvent(a.severity()),  
    425                                                 a.timestamp(), Event::unclassified, hal::safe_from_utf8(a.msg()))));             
     425                                                a.timestamp(), Event::unclassified, hal::from_utf8_safe(a.msg()))));             
    426426                } 
    427427                 
     
    642642{\ 
    643643        event().post(shared_ptr<EventDetail>(\ 
    644                 new EventInvalidTorrent(Event::critical, Event::invalidTorrent, TORRENT, FUNCTION)));\ 
     644                new EventInvalidTorrent(Event::critical, Event::invalidTorrent, TORRENT, std::string(FUNCTION))));\ 
    645645}\ 
    646646catch (const invalidTorrent& t)\ 
    647647{\ 
    648648        event().post(shared_ptr<EventDetail>(\ 
    649                 new EventInvalidTorrent(Event::critical, Event::invalidTorrent, hal::to_utf8(t.who()), FUNCTION)));\ 
     649                new EventInvalidTorrent(Event::critical, Event::invalidTorrent, t.who(), std::string(FUNCTION))));\ 
    650650}\ 
    651651catch (const std::exception& e)\ 
    652652{\ 
    653653        event().post(shared_ptr<EventDetail>(\ 
    654                 new EventTorrentException(Event::critical, Event::torrentException, e.what(), TORRENT, FUNCTION)));\ 
     654                new EventTorrentException(Event::critical, Event::torrentException, std::string(e.what()), TORRENT, std::string(FUNCTION))));\ 
    655655} 
    656656 
     
    10481048        lbt::torrent_info info(metadata); 
    10491049         
    1050         wstring torrentName = hal::safe_from_utf8(info.name()); 
     1050        wstring torrentName = hal::from_utf8_safe(info.name()); 
    10511051        if (!boost::find_last(torrentName, L".torrent"))  
    10521052                torrentName += L".torrent"; 
     
    11031103        if (p.second) 
    11041104        { 
    1105                         event().post(shared_ptr<EventDetail>( 
    1106                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), L"Here 1"))); 
    11071105                TorrentInternal& me = pimpl->theTorrents.get(torrent.name()); 
    1108                         event().post(shared_ptr<EventDetail>( 
    1109                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), L"Here 2"))); 
    11101106                TorrentManager::torrentByName::iterator i = p.first; 
    1111                         event().post(shared_ptr<EventDetail>( 
    1112                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), L"Here 3"))); 
    11131107                 
    11141108                me.setTransferSpeed(bittorrent().defTorrentDownload(), bittorrent().defTorrentUpload()); 
    1115                         event().post(shared_ptr<EventDetail>( 
    1116                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), L"Here 4"))); 
    1117                 me.setConnectionLimit(100, bittorrent().defTorrentMaxUpload()); 
    1118                         event().post(shared_ptr<EventDetail>( 
    1119                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), L"Here 5"))); 
     1109                me.setConnectionLimit(bittorrent().defTorrentMaxConn(), bittorrent().defTorrentMaxUpload()); 
    11201110                 
    11211111                me.addToSession(startPaused); 
    1122                         event().post(shared_ptr<EventDetail>( 
    1123                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), L"Here 6"))); 
    11241112        } 
    11251113         
     
    12101198} 
    12111199 
    1212 void BitTorrent::getAllTorrentDetail_vec(TorrentDetail_vec& torrentsContainer) 
    1213 { 
    1214         try { 
    1215          
    1216         torrentsContainer.reserve(pimpl->torrents.size()); 
    1217          
    1218         for (TorrentMap::iterator i=pimpl->torrents.begin(), e=pimpl->torrents.end(); i != e; ++i) 
    1219         { 
    1220                 torrentsContainer.push_back((*i).second.getTorrentDetail_ptr()); 
    1221         } 
    1222          
    1223         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "getAllTorrentDetail_vec") 
    1224 } 
    1225  
    1226 TorrentDetail_ptr BitTorrent::getTorrentDetail_vec(string filename) 
    1227 { 
    1228         try { 
    1229          
    1230         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1231          
    1232         if (i != pimpl->torrents.end()) 
    1233         { 
    1234                 return i->second.getTorrentDetail_ptr(); 
    1235         } 
    1236          
    1237         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentDetail_ptr") 
    1238          
    1239         return TorrentDetail_ptr(); 
    1240 } 
    1241  
    1242 /*const TorrentDetails& BitTorrent::getTorrentDetails(std::string selected, std::set<std::string> allSelected) 
    1243 { 
    1244         return updateTorrentDetails(selected, allSelected); 
    1245 } 
    1246 */ 
    12471200const TorrentDetails& BitTorrent::torrentDetails() 
    12481201{ 
     
    12501203} 
    12511204 
    1252 const TorrentDetails& BitTorrent::updateTorrentDetails(std::string focused, std::set<std::string> selected) 
     1205const TorrentDetails& BitTorrent::updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected) 
    12531206{ 
    12541207        try { 
     
    12581211        torrentDetails_.clearAll(l); 
    12591212         
    1260         torrentDetails_.torrents_.reserve(pimpl->torrents.size()); 
     1213//      torrentDetails_.torrents_.reserve(pimpl->torrents.size()); 
    12611214         
    12621215        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e; ++i) 
    12631216        { 
    1264                 event().post(shared_ptr<EventDetail>( 
    1265                         new EventGeneral(Event::info, boost::posix_time::second_clock::universal_time(), 
    1266                                 wformat(L"Torrent %1%, %2%-%3%") 
    1267                                                                 % (*i).torrent.name() 
    1268                                                                 % (*i).torrent.getConnectionLimit().first 
    1269                                                                 % (*i).torrent.getConnectionLimit().second))); 
    1270                                                  
    1271                 string utf8Filename = hal::to_utf8((*i).torrent.filename()); 
     1217                wstring utf8Name = (*i).torrent.name(); 
    12721218                TorrentDetail_ptr pT = (*i).torrent.getTorrentDetail_ptr(); 
    12731219                 
    1274                 if (selected.find(utf8Filename) != selected.end()) 
     1220                if (selected.find(utf8Name) != selected.end()) 
    12751221                { 
    12761222                        torrentDetails_.selectedTorrents_.push_back(pT); 
    12771223                } 
    12781224                 
    1279                 if (focused == utf8Filename) 
     1225                if (focused == utf8Name) 
    12801226                        torrentDetails_.selectedTorrent_ = pT; 
    12811227                 
    1282                 torrentDetails_.torrentMap_[(*i).torrent.filename()] = pT; 
     1228                torrentDetails_.torrentMap_[(*i).torrent.name()] = pT; 
    12831229                torrentDetails_.torrents_.push_back(pT); 
    12841230        } 
     
    12931239        try { 
    12941240         
    1295         for (TorrentMap::iterator iter = pimpl->torrents.begin();  
    1296                 iter != pimpl->torrents.end(); /*Nothing here*/) 
    1297         { 
    1298                 wpath file = pimpl->workingDirectory/L"torrents"/from_utf8((*iter).first); 
     1241        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e;) 
     1242        { 
     1243                wpath file = wpath(pimpl->workingDirectory)/L"torrents"/wpath((*i).torrent.filename());; 
     1244                 
     1245                //  vvv Handle old naming style! 
     1246                if ((*i).torrent.originalFilename() != L"") 
     1247                        file = wpath(pimpl->workingDirectory)/L"torrents"/wpath((*i).torrent.originalFilename()); 
     1248                //  ^^^ Handle old naming style!         
    12991249                 
    13001250                if (exists(file)) 
    13011251                {                
    13021252                        try  
    1303                         {                                
    1304                         std::pair<lbt::entry, lbt::entry> data = pimpl->prepTorrent(file, (*iter).second.saveDirectory()); 
    1305                          
    1306                         (*iter).second.setEntryData(data.first, data.second); 
    1307                          
    1308                         if ((*iter).second.state() == TorrentDetail::torrent_paused) 
    1309                                 (*iter).second.pause(); 
    1310                         else if ((*iter).second.state() == TorrentDetail::torrent_stopped) 
    1311                                 (*iter).second.stop();   
    1312                         else 
    1313                                 (*iter).second.resume(); 
    1314                          
    1315                         ++iter; 
     1253                        { 
     1254                                 
     1255                        (*i).torrent.prepare(file, (*i).torrent.saveDirectory(), pimpl->workingDirectory);       
     1256 
     1257                        switch ((*i).torrent.state()) 
     1258                        { 
     1259                                case TorrentDetail::torrent_stopped: 
     1260                                        break; 
     1261                                case TorrentDetail::torrent_paused: 
     1262                                        (*i).torrent.addToSession(true); 
     1263                                        break; 
     1264                                case TorrentDetail::torrent_active: 
     1265                                        (*i).torrent.addToSession(false); 
     1266                                        break; 
     1267                        }; 
     1268                         
     1269                        ++i; 
     1270                         
    13161271                        } 
    13171272                        catch(const lbt::duplicate_torrent&) 
     
    13191274                                hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::debug, L"Encountered duplicate torrent"))); 
    13201275                                 
    1321                                 ++iter; // Harmless, don't worry about it. 
     1276                                ++i; // Harmless, don't worry about it. 
    13221277                        } 
    13231278                        catch(const std::exception& e)  
     
    13251280                                hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventStdException(hal::Event::warning, e, L"resumeAll"))); 
    13261281                                 
    1327                                 pimpl->torrents.erase(iter++); 
     1282                                pimpl->theTorrents.erase(i++); 
    13281283                        }                        
    13291284                } 
    13301285                else 
    13311286                { 
    1332                         pimpl->torrents.erase(iter++); 
     1287                        pimpl->theTorrents.erase(i++); 
    13331288                } 
    13341289        } 
     
    13491304                new EventInfo(L"Stopping all torrents."))); 
    13501305         
    1351         for (TorrentMap::const_iterator i=pimpl->torrents.begin(), e=pimpl->torrents.end(); i != e; ++i) 
    1352         { 
    1353                 if ((*i).second.inSession()) 
    1354                 { 
    1355                         (*i).second.handle().pause(); // NB. internal pause, not registered in Torrents.xml 
    1356                 } 
    1357         } 
    1358  
     1306        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end();  
     1307                i != e; ++i) 
     1308        { 
     1309                if ((*i).torrent.inSession()) 
     1310                { 
     1311                        (*i).torrent.handle().pause(); // NB. internal pause, not registered in Torrents.xml 
     1312                } 
     1313        } 
    13591314         
    13601315        // Ok this polling loop here is a bit curde, but a blocking wait is actually appropiate. 
     
    13881343 
    13891344PeerDetail::PeerDetail(lbt::peer_info& peerInfo) : 
    1390         ipAddress(hal::safe_from_utf8(peerInfo.ip.address().to_string())), 
     1345        ipAddress(hal::from_utf8_safe(peerInfo.ip.address().to_string())), 
    13911346        country(L""), 
    13921347        speed(make_pair(peerInfo.payload_down_speed, peerInfo.payload_up_speed)), 
    13931348        seed(peerInfo.seed), 
    1394         client(hal::safe_from_utf8(peerInfo.client)) 
     1349        client(hal::from_utf8_safe(peerInfo.client)) 
    13951350{ 
    13961351        std::vector<wstring> status_vec; 
     
    13981353#ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES 
    13991354        if (peerInfo.country[0] != 0 && peerInfo.country[1] != 0) 
    1400                 country = (wformat(L"(%1%)") % hal::safe_from_utf8(string(peerInfo.country, 2))).str().c_str(); 
     1355                country = (wformat(L"(%1%)") % hal::from_utf8_safe(string(peerInfo.country, 2))).str().c_str(); 
    14011356#endif   
    14021357 
     
    14721427} 
    14731428 
    1474 bool BitTorrent::isTorrent(string filename) 
     1429bool BitTorrent::isTorrent(const std::string& filename) 
    14751430{        
    1476         try { 
    1477          
    1478         return (pimpl->torrents.find(filename) != pimpl->torrents.end()); 
     1431        return isTorrent(hal::to_wstr(filename)); 
     1432} 
     1433 
     1434bool BitTorrent::isTorrent(const std::wstring& filename) 
     1435{        
     1436        try { 
     1437         
     1438        return pimpl->theTorrents.exists(filename); 
    14791439         
    14801440        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrent") 
     
    14831443} 
    14841444 
    1485 void BitTorrent::pauseTorrent(string filename) 
    1486 { 
    1487         try { 
    1488          
    1489         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1490          
    1491         if (i != pimpl->torrents.end()) 
    1492         { 
    1493                 (*i).second.pause(); 
    1494         } 
     1445void BitTorrent::pauseTorrent(const std::string& filename) 
     1446{ 
     1447        pauseTorrent(hal::to_wstr(filename)); 
     1448} 
     1449 
     1450void BitTorrent::pauseTorrent(const std::wstring& filename) 
     1451{ 
     1452        try { 
     1453         
     1454        pimpl->theTorrents.get(filename).pause(); 
    14951455         
    14961456        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "pauseTorrent") 
    14971457} 
    14981458 
    1499 void BitTorrent::resumeTorrent(string filename) 
    1500 { 
    1501         try { 
    1502          
    1503         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1504          
    1505         if (i != pimpl->torrents.end()) 
    1506         { 
    1507                 (*i).second.resume(); 
    1508         } 
     1459void BitTorrent::resumeTorrent(const std::string& filename) 
     1460{ 
     1461        resumeTorrent(hal::to_wstr(filename)); 
     1462} 
     1463 
     1464void BitTorrent::resumeTorrent(const std::wstring& filename) 
     1465{ 
     1466        try { 
     1467         
     1468        pimpl->theTorrents.get(filename).resume(); 
    15091469         
    15101470        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resumeTorrent") 
    15111471} 
    15121472 
    1513 void BitTorrent::stopTorrent(string filename) 
    1514 { 
    1515         try { 
    1516          
    1517         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1518          
    1519         if (i != pimpl->torrents.end()) 
    1520         { 
    1521                 (*i).second.stop(); 
    1522         } 
     1473void BitTorrent::stopTorrent(const std::string& filename) 
     1474{ 
     1475        stopTorrent(hal::to_wstr(filename)); 
     1476} 
     1477 
     1478void BitTorrent::stopTorrent(const std::wstring& filename) 
     1479{ 
     1480        try { 
     1481         
     1482        pimpl->theTorrents.get(filename).stop(); 
    15231483         
    15241484        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "stopTorrent") 
    15251485} 
    15261486 
    1527 bool BitTorrent::isTorrentActive(string filename) 
    1528 { 
    1529         try { 
    1530          
    1531         TorrentMap::const_iterator i = pimpl->torrents.find(filename); 
    1532          
    1533         if (i != pimpl->torrents.end()) 
    1534         { 
    1535                 return (*i).second.isActive(); 
    1536         } 
     1487bool BitTorrent::isTorrentActive(const std::string& filename) 
     1488{ 
     1489        return isTorrentActive(hal::to_wstr(filename)); 
     1490} 
     1491 
     1492bool BitTorrent::isTorrentActive(const std::wstring& filename) 
     1493{ 
     1494        try { 
     1495         
     1496        return pimpl->theTorrents.get(filename).isActive(); 
    15371497         
    15381498        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "isTorrentActive") 
     
    15411501} 
    15421502 
    1543 void BitTorrent::setTorrentLogin(std::string filename, std::wstring username, std::wstring password) 
    1544 { 
    1545         try { 
    1546          
    1547         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1548          
    1549         if (i != pimpl->torrents.end()) 
    1550         { 
    1551                 (*i).second.setTrackerLogin(username, password); 
    1552         } 
     1503void BitTorrent::reannounceTorrent(const std::string& filename) 
     1504{ 
     1505        reannounceTorrent(hal::to_wstr(filename)); 
     1506} 
     1507 
     1508void BitTorrent::reannounceTorrent(const std::wstring& filename) 
     1509{ 
     1510        try { 
     1511         
     1512        pimpl->theTorrents.get(filename).handle().force_reannounce(); 
     1513         
     1514        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent") 
     1515} 
     1516 
     1517void BitTorrent::setTorrentLogin(const std::string& filename, std::wstring username, std::wstring password) 
     1518{ 
     1519        setTorrentLogin(hal::to_wstr(filename), username, password); 
     1520} 
     1521 
     1522void BitTorrent::setTorrentLogin(const std::wstring& filename, std::wstring username, std::wstring password) 
     1523{ 
     1524        try { 
     1525         
     1526        pimpl->theTorrents.get(filename).setTrackerLogin(username, password); 
    15531527         
    15541528        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentLogin") 
    15551529} 
    15561530 
    1557 std::pair<std::wstring, std::wstring> BitTorrent::getTorrentLogin(std::string filename) 
    1558 { 
    1559         try { 
    1560          
    1561         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1562          
    1563         if (i != pimpl->torrents.end()) 
    1564         { 
    1565                 return (*i).second.getTrackerLogin(); 
    1566         } 
     1531std::pair<std::wstring, std::wstring> BitTorrent::getTorrentLogin(const std::string& filename) 
     1532{ 
     1533        return getTorrentLogin(hal::to_wstr(filename)); 
     1534} 
     1535 
     1536std::pair<std::wstring, std::wstring> BitTorrent::getTorrentLogin(const std::wstring& filename) 
     1537{ 
     1538        try { 
     1539         
     1540        return pimpl->theTorrents.get(filename).getTrackerLogin(); 
    15671541         
    15681542        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentLogin") 
     
    16031577} 
    16041578 
    1605 void BitTorrent::removeTorrent(string filename) 
    1606 { 
    1607         try { 
    1608          
    1609         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1610          
    1611         if (i != pimpl->torrents.end()) 
    1612         { 
    1613                 lbt::torrent_handle handle = (*i).second.handle(); 
    1614                 pimpl->torrents.erase(i); 
    1615                 thread t(bind(&BitTorrent_impl::removalThread, &*pimpl, handle, false)); 
    1616         } 
     1579void BitTorrent::removeTorrent(const std::string& filename) 
     1580{ 
     1581        removeTorrent(hal::to_wstr(filename)); 
     1582} 
     1583 
     1584void BitTorrent::removeTorrent(const std::wstring& filename) 
     1585{ 
     1586        try { 
     1587         
     1588        lbt::torrent_handle handle = pimpl->theTorrents.get(filename).handle(); 
     1589        pimpl->theTorrents.erase(filename); 
     1590                 
     1591        thread t(bind(&BitTorrent_impl::removalThread, &*pimpl, handle, false)); 
    16171592         
    16181593        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "removeTorrent") 
    16191594} 
    16201595 
    1621 void BitTorrent::removeTorrentWipeFiles(string filename) 
    1622 { 
    1623         try { 
    1624          
    1625         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1626          
    1627         if (i != pimpl->torrents.end()) 
    1628         { 
    1629                 lbt::torrent_handle handle = (*i).second.handle(); 
    1630                 pimpl->torrents.erase(i); 
    1631                 thread t(bind(&BitTorrent_impl::removalThread, &*pimpl, handle, true)); 
    1632         } 
     1596void BitTorrent::removeTorrentWipeFiles(const std::string& filename) 
     1597{ 
     1598        removeTorrentWipeFiles(hal::to_wstr(filename)); 
     1599} 
     1600 
     1601void BitTorrent::removeTorrentWipeFiles(const std::wstring& filename) 
     1602{ 
     1603        try { 
     1604                 
     1605        lbt::torrent_handle handle = pimpl->theTorrents.get(filename).handle(); 
     1606        pimpl->theTorrents.erase(filename); 
     1607                 
     1608        thread t(bind(&BitTorrent_impl::removalThread, &*pimpl, handle, true)); 
    16331609         
    16341610        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "removeTorrentWipeFiles") 
    1635 } 
    1636  
    1637 void BitTorrent::reannounceTorrent(string filename) 
    1638 { 
    1639         try { 
    1640          
    1641         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1642          
    1643         if (i != pimpl->torrents.end()) 
    1644         { 
    1645                 (*i).second.handle().force_reannounce(); 
    1646         } 
    1647          
    1648         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "reannounceTorrent") 
    1649  
    1650 //      pimpl->theSession.add_dht_node(make_pair(string("192.168.11.4"),6881)); 
    1651 //      Temporary Hijack 
    1652  
    1653 /*      ofstream out("dump.txt"); 
    1654          
    1655         lbt::entry ent = pimpl->theSession.dht_state(); 
    1656         lbt::entry::dictionary_type dic = ent.dict(); 
    1657          
    1658         for (lbt::entry::dictionary_type::iterator j = dic.begin();  
    1659                 j != dic.end(); ++j) 
    1660         { 
    1661                 out << (*j).first << " " << (*j).second << std::endl; 
    1662         }                
    1663 */       
    16641611} 
    16651612 
  • src/halTorrent.hpp

    r290 r291  
    128128{ 
    129129public: 
    130         TorrentDetail(std::wstring f, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
     130        TorrentDetail(std::wstring f, std::wstring n, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
    131131                        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 prs=0, int prsCnt=0, int sds=0, int sdsCnt=0,  float r=0,  
    132132                        time_duration eta=boost::posix_time::seconds(0), time_duration uIn=boost::posix_time::seconds(0), 
    133133                        time_duration actve=boost::posix_time::seconds(0), time_duration seding=boost::posix_time::seconds(0), ptime srt=boost::posix_time::second_clock::universal_time()) : 
    134134                filename_(f), 
     135                name_(n), 
    135136                state_(s), 
    136137                currentTracker_(cT), 
     
    171172         
    172173        const std::wstring& filename() const { return filename_; } 
     174        const std::wstring& name() const { return name_; } 
    173175        const std::wstring& state() const { return state_; } 
    174176        const std::wstring& currentTracker() const { return currentTracker_; } 
     
    204206public: 
    205207        std::wstring filename_; 
     208        std::wstring name_; 
    206209        std::wstring state_; 
    207210        std::wstring currentTracker_; 
     
    337340{ 
    338341public:  
     342 
    339343        void shutDownSession(); 
    340344        void saveTorrentData(); 
     
    369373        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files); 
    370374        void addTorrent(boost::filesystem::wpath file, wpath saveDirectory, bool startPaused=false, bool compactStorage=false); 
    371         void getAllTorrentDetail_vec(TorrentDetail_vec& torrentsContainer); 
    372         TorrentDetail_ptr getTorrentDetail_vec(std::string filename);    
    373375         
    374376        void setTorrentRatio(std::string, float ratio); 
     
    381383        void closeAll(); 
    382384         
    383         bool isTorrent(std::string filename); 
    384          
    385         void pauseTorrent(std::string filename); 
    386         void resumeTorrent(std::string filename); 
    387         void stopTorrent(std::string filename); 
    388         bool isTorrentActive(std::string filename); 
     385        bool isTorrent(const std::string& filename); 
     386        bool isTorrent(const std::wstring& filename);    
     387         
     388        void pauseTorrent(const std::string& filename); 
     389        void pauseTorrent(const std::wstring& filename); 
     390        void resumeTorrent(const std::string& filename); 
     391        void resumeTorrent(const std::wstring& filename); 
     392        void stopTorrent(const std::string& filename); 
     393        void stopTorrent(const std::wstring& filename); 
     394        bool isTorrentActive(const std::string& filename); 
     395        bool isTorrentActive(const std::wstring& filename); 
     396        void reannounceTorrent(const std::string& filename); 
     397        void reannounceTorrent(const std::wstring& filename); 
    389398         
    390399        void pauseAllTorrents(); 
    391400        void unpauseAllTorrents(); 
    392401         
    393         void removeTorrent(std::string filename); 
    394         void removeTorrentWipeFiles(std::string filename); 
    395         void reannounceTorrent(std::string filename); 
    396          
    397         void setTorrentLogin(std::string filename, std::wstring username, std::wstring password); 
    398         std::pair<std::wstring, std::wstring> getTorrentLogin(std::string filename); 
     402        void removeTorrent(const std::string& filename); 
     403        void removeTorrent(const std::wstring&  filename); 
     404        void removeTorrentWipeFiles(const std::string& filename); 
     405        void removeTorrentWipeFiles(const std::wstring&  filename); 
     406         
     407        void setTorrentLogin(const std::string& filename, std::wstring username, std::wstring password); 
     408        void setTorrentLogin(const std::wstring& filename, std::wstring username, std::wstring password); 
     409        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::string& filename); 
     410        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::wstring&  filename); 
    399411         
    400412        void setTorrentLimit(std::string filename, int maxConn, int maxUpload); 
     
    421433        const TorrentDetails& torrentDetails(); 
    422434//      const TorrentDetails& getTorrentDetails(std::string selected, std::set<std::string> allSelected);        
    423         const TorrentDetails& updateTorrentDetails(std::string focused, std::set<std::string> selected); 
     435        const TorrentDetails& updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected); 
    424436         
    425437private: 
  • src/halTorrentInternal.hpp

    r290 r291  
    1919} 
    2020 
    21 BOOST_CLASS_VERSION(hal::TorrentInternal, 8) 
     21BOOST_CLASS_VERSION(hal::TorrentInternal, 9) 
    2222 
    2323namespace hal  
     
    172172public: 
    173173        #define TORRENT_INTERNALS_DEFAULTS \ 
     174                originalFilename_(L""), \ 
    174175                transferLimit_(std::pair<float, float>(-1, -1)), \ 
    175176                connections_(-1), \ 
     
    187188        {} 
    188189         
    189         TorrentInternal(libtorrent::torrent_handle h, std::wstring f, wpath saveDirectory) : 
    190                 TORRENT_INTERNALS_DEFAULTS, 
    191                 filename_(f), 
    192                 save_directory_(saveDirectory.string()), 
    193                 in_session_(true), 
    194                 handle_(h) 
    195         { 
    196                 name_ = L""; 
    197         } 
    198          
    199190        TorrentInternal(wpath filename, wpath saveDirectory, wpath workingDirectory, bool compactStorage) : 
    200191                TORRENT_INTERNALS_DEFAULTS, 
     
    205196                assert(the_session_); 
    206197                 
    207                 prep(filename, save_directory_, workingDirectory); 
     198                prepare(filename, save_directory_, workingDirectory); 
    208199        } 
    209200         
     
    249240        bool inSession() const  
    250241        {  
    251                 return (in_session_ && the_session_);  
     242                if (in_session_ && (the_session_ != 0)) 
     243                { 
     244                        assert(handle_.is_valid()); 
     245                        return true; 
     246                } 
     247                 
     248                return false; 
    252249        } 
    253250         
    254251        void resume() 
    255252        { 
    256                 addToSession();  
    257                 assert(in_session_); 
    258                  
    259                 handle_.resume(); 
    260                 state_ = TorrentDetail::torrent_active; 
    261                  
    262                 activeDuration_.reset(); 
    263                 seedingDuration_.reset(); 
    264                  
     253                if (state_ == TorrentDetail::torrent_stopped) 
     254                {        
     255                        addToSession(false); 
     256                        assert(inSession());                     
     257                } 
     258                else 
     259                { 
     260                        assert(inSession()); 
     261                        handle_.resume(); 
     262                }        
     263                 
     264                state_ = TorrentDetail::torrent_active;                  
    265265                assert(!handle_.is_paused()); 
    266266        } 
     
    268268        void pause() 
    269269        { 
    270                 if (state_ != TorrentDetail::torrent_stopped) 
     270                if (state_ == TorrentDetail::torrent_stopped) 
    271271                {        
    272272                        addToSession(true); 
    273                         assert(in_session_); 
    274                          
    275                         state_ = TorrentDetail::torrent_paused;  
    276                          
    277                         assert(handle_.is_paused()); 
    278                 } 
     273                        assert(inSession());                     
     274                } 
     275                else 
     276                { 
     277                        assert(inSession()); 
     278                        handle_.pause(); 
     279                }        
     280                 
     281                state_ = TorrentDetail::torrent_paused;                  
     282                assert(handle_.is_paused()); 
    279283        } 
    280284         
    281285        void stop() 
    282286        { 
    283                 if (in_session_ && the_session_)  
     287                if (state_ != TorrentDetail::torrent_stopped) 
    284288                { 
    285289                        the_session_->remove_torrent(handle_); 
    286290                        in_session_ = false; 
    287291                } 
    288                 assert(!in_session_); 
    289                  
    290                 state_ = TorrentDetail::torrent_stopped;         
     292                 
     293                state_ = TorrentDetail::torrent_stopped; 
     294                assert(!inSession());                    
    291295        } 
    292296         
     
    310314        const std::wstring& filename() const { return filename_; } 
    311315         
     316        const std::wstring& originalFilename() const { return originalFilename_; } 
     317         
    312318        const libtorrent::torrent_handle& handle() const { return handle_; } 
    313319 
    314         void setHandle(libtorrent::torrent_handle h)  
    315         {  
    316                 handle_ = h;  
    317                 in_session_ = true; 
    318         } 
    319          
    320320        void resetTrackers() 
    321321        { 
     
    369369        ar & make_nvp("transferLimit", transferLimit_); 
    370370        ar & make_nvp("connections", connections_); 
    371         ar & make_nvp("uploads", uploads_); 
    372         ar & make_nvp("filename", filename_); 
     371        ar & make_nvp("uploads", uploads_);              
     372                if (version > 8) { 
     373                        ar & make_nvp("filename", filename_); 
     374                } 
     375                else { 
     376                        ar & make_nvp("filename", originalFilename_); 
     377                } 
    373378        ar & make_nvp("saveDirectory", save_directory_); 
    374379                 
     
    410415                        ar & make_nvp("name", name_);            
    411416                } 
    412                 else 
    413                 { 
     417                else { 
    414418                        name_ = filename_; 
    415419                } 
    416420                if (version > 7) { 
    417421                        ar & make_nvp("compactStorage", compactStorage_);                
    418                 } 
    419                  
     422                }                
    420423    } 
    421424         
     
    472475                } 
    473476        } 
    474  
    475 private: 
    476         void prep(wpath filename, wpath saveDirectory, wpath workingDirectory) 
     477         
     478        void prepare(wpath filename, wpath saveDirectory, wpath workingDirectory) 
    477479        { 
    478480         
     
    480482                info_ = lbt::torrent_info(metadata_); 
    481483                 
    482                 name_ = hal::safe_from_utf8(info_.name()); 
     484                name_ = hal::from_utf8_safe(info_.name()); 
    483485                 
    484486                filename_ = name_; 
     
    492494                const wpath oldResumeFile = workingDirectory/L"resume"/filename.leaf(); 
    493495                 
    494                 if (resumeFile != oldResumeFile && exists(oldResumeFile)) 
     496                if (resumeFile != oldResumeFile && !exists(resumeFile) && exists(oldResumeFile)) 
    495497                        fs::rename(oldResumeFile, resumeFile); 
    496498                //  ^^^ Handle old naming style!         
     
    520522                        create_directory(saveDirectory);         
    521523        } 
     524 
     525private: 
    522526         
    523527        void applySettings() 
     
    622626        std::wstring name_; 
    623627        std::wstring save_directory_; 
     628        std::wstring originalFilename_; 
    624629        libtorrent::torrent_handle handle_;      
    625630         
     
    756761        } 
    757762         
     763        torrentByName::iterator erase(torrentByName::iterator where) 
     764        { 
     765                return torrents_.get<byName>().erase(where); 
     766        } 
     767         
     768        size_t erase(const wstring& name) 
     769        { 
     770                return torrents_.get<byName>().erase(name); 
     771        } 
     772         
     773        bool exists(const wstring& name) 
     774        { 
     775                torrentByName::iterator it = torrents_.get<byName>().find(name); 
     776                 
     777                if (it != torrents_.get<byName>().end()) 
     778                        return true; 
     779                else 
     780                        return false; 
     781        } 
     782         
    758783        torrentByName::iterator begin() { return torrents_.get<byName>().begin(); } 
    759784        torrentByName::iterator end() { return torrents_.get<byName>().end(); } 
     
    804829        { 
    805830                statusMemory_ = handle_.status(); 
    806                 name_ = hal::safe_from_utf8(handle_.get_torrent_info().name()); 
     831                name_ = hal::from_utf8_safe(handle_.get_torrent_info().name()); 
    807832        } 
    808833         
     
    892917        }                        
    893918 
    894         return TorrentDetail_ptr(new TorrentDetail(filename_, state, hal::from_utf8(statusMemory_.current_tracker),  
     919        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, state, hal::from_utf8(statusMemory_.current_tracker),  
    895920                pair<float, float>(statusMemory_.download_payload_rate, statusMemory_.upload_payload_rate), 
    896921                statusMemory_.progress, statusMemory_.distributed_copies, statusMemory_.total_wanted_done, statusMemory_.total_wanted, uploaded_, payloadUploaded_, 
     
    909934        } 
    910935         
    911         return TorrentDetail_ptr(new TorrentDetail(filename_, app().res_wstr(HAL_TORRENT_STOPPED),  app().res_wstr(IDS_NA))); 
     936        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, app().res_wstr(HAL_TORRENT_STOPPED),  app().res_wstr(IDS_NA))); 
    912937} 
    913938 
Note: See TracChangeset for help on using the changeset viewer.