Changeset 437


Ignore:
Timestamp:
05/12/08 20:17:16 (12 years ago)
Author:
Eoin
Message:

Editing torrent folders added.

Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/res/Halite.rc

    r436 r437  
    538538        MENUITEM SEPARATOR 
    539539        MENUITEM "Open Download Folder",ID_LVM_DOWNLOAD_FOLDER 
     540        MENUITEM "Edit Download Folders",ID_LVM_EDIT_FOLDERS 
    540541    END 
    541542END 
  • trunk/src/AddTorrentDialog.hpp

    r436 r437  
    88 
    99#define ID_ADD_TORRENT_BEGIN            11000 
    10 #define IDC_ADDT_DEFFLD_TEXT            ID_ADD_TORRENT_BEGIN + 6 
    11 #define IDC_ADDT_NOTE_TEXT                      ID_ADD_TORRENT_BEGIN + 8 
    12 #define HAL_ADJUST_DLG_HOLDER           ID_ADD_TORRENT_BEGIN + 9 
     10#define HAL_ADJUST_DLG_HOLDER           ID_ADD_TORRENT_BEGIN + 1 
    1311 
    1412#ifndef RC_INVOKED 
     
    3937        { Load(); } 
    4038 
    41         ~AddTorrentDialog() { Save(); }  
     39        ~AddTorrentDialog()  
     40        { Save(); }      
    4241 
    4342        enum { IDD = IDD_ADD_TORRENT }; 
  • trunk/src/ConfigOptions.cpp

    r433 r437  
    11 
    2 //         Copyright Eóin O'Callaghan 2006 - 2007. 
     2//         Copyright Eóin O'Callaghan 2006 - 2008. 
    33// Distributed under the Boost Software License, Version 1.0. 
    44//    (See accompanying file LICENSE_1_0.txt or copy at 
  • trunk/src/HaliteListView.cpp

    r429 r437  
    1010#include "HaliteListView.hpp" 
    1111#include "HaliteWindow.hpp" 
     12#include "HaliteListViewDlg.hpp" 
     13 
    1214#include "halTorrent.hpp" 
    1315 
     
    2729        array<int, 21> widths = {100,110,60,60,60,42,45,61,45,45,45,45,45,45,45,45,45,45,45,45,45}; 
    2830        array<int, 21> order = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20}; 
    29         array<bool, 21> visible = {true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true}; 
     31        array<bool, 21> visible = {true,true,true,true,true,true,true,true,true,true,true,\ 
     32                true,true,true,true,true,true,true,true,true,true}; 
    3033         
    3134        SetDefaults(names, widths, order, visible); 
     
    214217} 
    215218 
     219LRESULT HaliteListViewCtrl::OnEditFolders(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
     220{ 
     221        HAL_DEV_MSG(L"OnEditFolders"); 
     222 
     223        hal::BitTorrent::torrent t = hal::bittorrent().get(manager_.selected()); 
     224 
     225        wstring saveDirectory = static_cast<wpath>(t.save_directory).native_file_string(); 
     226        wstring moveToDirectory = static_cast<wpath>(t.move_to_directory).native_file_string(); 
     227        bool useMoveTo = (L"" != moveToDirectory); 
     228 
     229        HaliteListViewAdjustDlg addTorrent(L"Hello", saveDirectory, moveToDirectory, useMoveTo);         
     230         
     231        if (IDOK == addTorrent.DoModal()) 
     232        { 
     233                t.save_directory = saveDirectory; 
     234 
     235                if (useMoveTo) 
     236                        t.move_to_directory = moveToDirectory; 
     237                else 
     238                        t.move_to_directory = L""; 
     239        } 
     240 
     241        return 0; 
     242} 
     243 
    216244//LRESULT HaliteListViewCtrl::OnDeleteItem(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) 
    217245//{ 
  • trunk/src/HaliteListView.hpp

    r436 r437  
    1010#define ID_LVM_DOWNLOAD_FOLDER          HAL_MAIN_LISTVIEW_BEGIN + 1 
    1111#define ID_LVM_RECHECK                                  HAL_MAIN_LISTVIEW_BEGIN + 2 
     12#define ID_LVM_EDIT_FOLDERS                             HAL_MAIN_LISTVIEW_BEGIN + 3 
    1213 
    1314#ifndef RC_INVOKED 
     
    346347                COMMAND_ID_HANDLER(ID_LVM_REMOVE_TD, OnRemoveWipeFiles) 
    347348                COMMAND_ID_HANDLER(ID_LVM_DOWNLOAD_FOLDER, OnDownloadFolder) 
     349                COMMAND_ID_HANDLER(ID_LVM_EDIT_FOLDERS, OnEditFolders) 
    348350 
    349351                CHAIN_MSG_MAP(listClass) 
     
    364366        LRESULT OnRemoveWipeFiles(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
    365367        LRESULT OnDownloadFolder(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
     368        LRESULT OnEditFolders(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
    366369 
    367370    friend class boost::serialization::access; 
  • trunk/src/HaliteListViewDlg.hpp

    r436 r437  
    1414#define IDC_ADDT_MOVETO_BROWSE                  HAL_ADJUST_DLG_BEGIN + 2 
    1515#define IDC_ADDT_MOVETO_CHECK                   HAL_ADJUST_DLG_BEGIN + 3 
     16#define IDC_ADDT_DEFFLD_TEXT                    HAL_ADJUST_DLG_BEGIN + 4 
     17#define IDC_ADDT_NOTE_TEXT                              HAL_ADJUST_DLG_BEGIN + 5 
    1618 
    1719#ifndef RC_INVOKED 
  • trunk/src/HaliteWindow.cpp

    r436 r437  
    357357        if (!boost::filesystem::exists(saveDirectory)) 
    358358                boost::filesystem::create_directory(saveDirectory); 
    359          
    360 /*      HaliteListViewAdjustDlg addTorrent(L"Hello", saveDirectory, moveToDirectory, useMoveTo);         
    361          
    362         if (IDOK != addTorrent.DoModal()) 
    363                 return; 
    364         return; 
    365 */ 
     359 
    366360        if (hal::config().savePrompt) 
    367361        { 
  • trunk/src/advtabs/Torrent.cpp

    r392 r437  
    110110                hal::bittorrent().setTorrentLimit(torrentName, totalConnections_, uploadConnections_); 
    111111                hal::bittorrent().setTorrentRatio(torrentName, ratio_); 
     112 
     113//              hal::BitTorrent::torrent t = hal::bittorrent().get(torrent->name()); 
     114 
     115//              t.ratio = ratio_; 
    112116        } 
    113117         
  • trunk/src/global/string_conv.hpp

    r429 r437  
    111111}; 
    112112 
    113  
    114  
    115113template<typename str_t> 
    116 inline std::wstring to_wstr_shim(str_t& s) 
     114inline const std::wstring to_wstr_shim(str_t& s) 
    117115{ 
    118116        return s; 
     
    120118 
    121119template<> 
    122 inline std::wstring to_wstr_shim<const wchar_t *const>(const wchar_t *const& s) 
     120inline const std::wstring to_wstr_shim<const wchar_t *const>(const wchar_t *const& s) 
    123121{ 
    124122        return std::wstring(s); 
     
    126124 
    127125template<> 
    128 inline std::wstring to_wstr_shim<const wchar_t *>(const wchar_t *& s) 
     126inline const std::wstring to_wstr_shim<const wchar_t *>(const wchar_t *& s) 
    129127{ 
    130128        return std::wstring(s); 
     
    132130 
    133131template<> 
    134 inline std::wstring to_wstr_shim<const char *>(const char *& s) 
     132inline const std::wstring to_wstr_shim<const char *>(const char *& s) 
    135133{ 
    136134        return from_utf8_safe(s); 
     
    138136 
    139137template<> 
    140 inline std::wstring to_wstr_shim<const char *const>(const char *const& s) 
     138inline const std::wstring to_wstr_shim<const char *const>(const char *const& s) 
    141139{ 
    142140        return from_utf8_safe(s); 
     
    144142 
    145143template<> 
    146 inline std::wstring to_wstr_shim<const std::string>(const std::string& s) 
     144inline const std::wstring to_wstr_shim<const std::string>(const std::string& s) 
    147145{ 
    148146        return from_utf8_safe(s); 
     
    150148 
    151149template<> 
    152 inline std::wstring to_wstr_shim<std::string>(std::string& s) 
     150inline const std::wstring to_wstr_shim<std::string>(std::string& s) 
    153151{ 
    154152        return from_utf8_safe(s); 
     
    156154 
    157155template<> 
    158 inline std::wstring to_wstr_shim<const boost::wformat>(const boost::wformat& f) 
     156inline const std::wstring to_wstr_shim<const boost::wformat>(const boost::wformat& f) 
    159157{ 
    160158        return f.str(); 
     
    162160 
    163161template<> 
    164 inline std::wstring to_wstr_shim<boost::wformat>(boost::wformat& f) 
     162inline const std::wstring to_wstr_shim<boost::wformat>(boost::wformat& f) 
    165163{ 
    166164        return f.str(); 
     
    168166 
    169167template<> 
    170 inline std::wstring to_wstr_shim<const boost::format>(const boost::format& f) 
     168inline const std::wstring to_wstr_shim<const boost::format>(const boost::format& f) 
    171169{ 
    172170        return from_utf8_safe(f.str()); 
     
    174172 
    175173template<> 
    176 inline std::wstring to_wstr_shim<boost::format>(boost::format& f) 
     174inline const std::wstring to_wstr_shim<boost::format>(boost::format& f) 
    177175{ 
    178176        return from_utf8_safe(f.str()); 
  • trunk/src/halTorrent.cpp

    r432 r437  
    2828 
    2929#include "halTorrent.hpp" 
     30#include "halTypes.hpp" 
    3031#include "halEvent.hpp" 
    3132#include "halSignaler.hpp" 
     
    7374} 
    7475 
     76template<class Archive, class String, class Traits> 
     77void save(Archive& ar, const boost::filesystem::basic_path<String, Traits>& p, const unsigned int version) 
     78{        
     79        String str = p.string(); 
     80        ar & BOOST_SERIALIZATION_NVP(str); 
     81} 
     82 
     83template<class Archive, class String, class Traits> 
     84void load(Archive& ar, boost::filesystem::basic_path<String, Traits>& p, const unsigned int version) 
     85{        
     86        String str; 
     87        ar & BOOST_SERIALIZATION_NVP(str); 
     88 
     89        p = str; 
     90} 
     91 
     92template<class Archive, class String, class Traits> 
     93inline void serialize( 
     94        Archive & ar, 
     95        boost::filesystem::basic_path<String, Traits>& p, 
     96        const unsigned int file_version 
     97){ 
     98        split_free(ar, p, file_version);             
     99} 
     100 
    75101template<class Archive, class address_type> 
    76102void serialize(Archive& ar, libtorrent::ip_range<address_type>& addr, const unsigned int version) 
     
    116142namespace hal  
    117143{ 
    118         libtorrent::session* TorrentInternal::the_session_ = 0; 
    119         wpath_t TorrentInternal::workingDir_; 
     144        libtorrent::session* torrent_internal::the_session_ = 0; 
     145        wpath torrent_internal::workingDir_; 
    120146} 
    121147 
     
    123149{ 
    124150 
    125 namespace lbt = libtorrent; 
    126 namespace fs = boost::filesystem; 
    127 namespace pt = boost::posix_time; 
    128  
    129 typedef std::wstring wstring_t; 
    130 typedef std::string string_t; 
    131  
    132 typedef boost::wformat wformat_t; 
    133 typedef boost::format format_t; 
    134  
    135 typedef boost::filesystem::wpath wpath_t; 
    136 typedef boost::filesystem::path path_t; 
    137  
    138 using boost::serialization::make_nvp; 
    139 using boost::shared_ptr; 
    140 using boost::bind; 
     151 
    141152 
    142153BitTorrent& bittorrent() 
     
    324335                { 
    325336                        event().post(shared_ptr<EventDetail>( 
    326                                 new EventMsg((wformat_t(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
     337                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
    327338                                                % get(a.handle)->name()),  
    328339                                        Event::info, a.timestamp()))); 
     
    334345                { 
    335346                        event().post(shared_ptr<EventDetail>( 
    336                                 new EventMsg((wformat_t(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
     347                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
    337348                                                % get(a.handle)->name()),  
    338349                                        Event::info, a.timestamp()))); 
     
    345356                        event().post(shared_ptr<EventDetail>( 
    346357                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    347                                         wformat_t(hal::app().res_wstr(HAL_PEER_ALERT)) 
     358                                        wformat(hal::app().res_wstr(HAL_PEER_ALERT)) 
    348359                                                % hal::from_utf8_safe(a.msg()) 
    349360                                                % hal::from_utf8_safe(a.ip.address().to_string())) 
     
    355366                        event().post(shared_ptr<EventDetail>( 
    356367                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    357                                         wformat_t(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
     368                                        wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
    358369                                                % get(a.handle)->name() 
    359370                                                % hal::from_utf8_safe(a.ip.address().to_string())) 
     
    365376                        event().post(shared_ptr<EventDetail>( 
    366377                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    367                                         wformat_t(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
     378                                        wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
    368379                                                % get(a.handle)->name() 
    369380                                                % a.piece_index) 
     
    375386                        event().post(shared_ptr<EventDetail>( 
    376387                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    377                                         wformat_t(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
     388                                        wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
    378389                                                % get(a.handle)->name() 
    379390                                                % hal::from_utf8_safe(a.url) 
     
    386397                        event().post(shared_ptr<EventDetail>( 
    387398                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    388                                         wformat_t(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
     399                                        wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
    389400                                                % get(a.handle)->name() 
    390401                                                % hal::from_utf8_safe(a.msg())) 
     
    395406                { 
    396407                        event().post(shared_ptr<EventDetail>( 
    397                                 new EventMsg((wformat_t(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
     408                                new EventMsg((wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
    398409                                                % get(a.handle)->name()),  
    399410                                        Event::info, a.timestamp()))); 
     
    404415                        event().post(shared_ptr<EventDetail>( 
    405416                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    406                                         wformat_t(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
     417                                        wformat(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
    407418                                                % get(a.handle)->name() 
    408419                                                % hal::from_utf8_safe(a.msg()) 
     
    416427                        event().post(shared_ptr<EventDetail>( 
    417428                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    418                                         wformat_t(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
     429                                        wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
    419430                                                % get(a.handle)->name() 
    420431                                                % hal::from_utf8_safe(a.msg()) 
     
    427438                        event().post(shared_ptr<EventDetail>( 
    428439                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    429                                         wformat_t(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
     440                                        wformat(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
    430441                                                % get(a.handle)->name() 
    431442                                                % hal::from_utf8_safe(a.msg())) 
     
    437448                        event().post(shared_ptr<EventDetail>( 
    438449                                new EventGeneral(Event::debug, a.timestamp(), 
    439                                         wformat_t(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT)) 
     450                                        wformat(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT)) 
    440451                                                % get(a.handle)->name() 
    441452                                                % a.piece_index) 
     
    447458                        event().post(shared_ptr<EventDetail>( 
    448459                                new EventGeneral(Event::debug, a.timestamp(), 
    449                                         wformat_t(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT)) 
     460                                        wformat(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT)) 
    450461                                                % get(a.handle)->name() 
    451462                                                % a.block_index 
     
    458469                        event().post(shared_ptr<EventDetail>( 
    459470                                new EventGeneral(Event::debug, a.timestamp(), 
    460                                         wformat_t(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT)) 
     471                                        wformat(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT)) 
    461472                                                % get(a.handle)->name() 
    462473                                                % a.block_index 
     
    478489                                event().post(shared_ptr<EventDetail>( 
    479490                                        new EventGeneral(Event::info, a.timestamp(), 
    480                                                 wformat_t(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
     491                                                wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
    481492                                                        % hal::from_utf8_safe(a.msg())) 
    482493                                )       ); 
     
    488499                        event().post(shared_ptr<EventDetail>( 
    489500                                new EventGeneral(Event::info, a.timestamp(), 
    490                                         wformat_t(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT)) 
     501                                        wformat(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT)) 
    491502                                                % hal::from_utf8_safe(a.msg())) 
    492503                        )       );       
     
    499510                        event().post(shared_ptr<EventDetail>( 
    500511                                new EventGeneral(Event::debug, a.timestamp(), 
    501                                         wformat_t(hal::app().res_wstr(HAL_IPFILTER_ALERT)) 
     512                                        wformat(hal::app().res_wstr(HAL_IPFILTER_ALERT)) 
    502513                                                % hal::from_utf8_safe(a.ip.to_string()) 
    503514                                                % hal::from_utf8_safe(a.msg())) 
     
    515526                        BitTorrent_impl& bit_impl_; 
    516527                         
    517                         TorrentInternal_ptr get(lbt::torrent_handle h) const  
     528                        torrent_internal_ptr get(lbt::torrent_handle h) const  
    518529                        {  
    519530                                return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name()));  
     
    593604        float defTorrentUpload() { return defTorrentUpload_; } 
    594605         
    595         const wpath_t workingDir() { return workingDirectory; }; 
     606        const wpath workingDir() { return workingDirectory; }; 
    596607 
    597608private: 
     
    612623                dht_on_(false) 
    613624        { 
    614                 TorrentInternal::the_session_ = &theSession; 
    615                 TorrentInternal::workingDir_ = workingDir(); 
     625                torrent_internal::the_session_ = &theSession; 
     626                torrent_internal::workingDir_ = workingDir(); 
    616627                 
    617628                theSession.set_severity_level(lbt::alert::debug);                
     
    640651                        TorrentMap torrents; 
    641652                        boost::archive::xml_wiarchive ia(ifs);   
    642                         ia >> make_nvp("torrents", torrents); 
     653                        ia >> slz::make_nvp("torrents", torrents); 
    643654                         
    644655                        theTorrents = torrents; 
     
    646657                         
    647658                        event().post(shared_ptr<EventDetail>(new EventMsg( 
    648                                 wformat_t(L"Total %1%.") % theTorrents.size())));                                
     659                                wformat(L"Total %1%.") % theTorrents.size())));                          
    649660                         
    650661                        fs::rename(workingDirectory/L"Torrents.xml", workingDirectory/L"Torrents.xml.safe.to.delete"); 
     
    671682                 
    672683                {       lbt::session_settings settings = theSession.settings(); 
    673                         settings.user_agent = string_t("Halite ") + HALITE_VERSION_STRING; 
     684                        settings.user_agent = string("Halite ") + HALITE_VERSION_STRING; 
    674685                        theSession.set_settings(settings); 
    675686                } 
     
    692703                                i != e; ++i) 
    693704                { 
    694                         HAL_DEV_MSG(wformat_t(L"file path: %1%, size: %2%") % (*i).first % (*i).second); 
     705                        HAL_DEV_MSG(wformat(L"file path: %1%, size: %2%") % (*i).first % (*i).second); 
    695706                        t_info->add_file(to_utf8((*i).first.string()), (*i).second); 
    696707                } 
     
    706717                                i != e; ++i) 
    707718                { 
    708                         HAL_DEV_MSG(wformat_t(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier); 
     719                        HAL_DEV_MSG(wformat(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier); 
    709720                        t_info->add_tracker(to_utf8((*i).url), (*i).tier); 
    710721                } 
     
    714725                                i != e; ++i) 
    715726                { 
    716                         HAL_DEV_MSG(wformat_t(L"URL: %1%") % (*i).url); 
     727                        HAL_DEV_MSG(wformat(L"URL: %1%") % (*i).url); 
    717728                        t_info->add_url_seed(to_utf8((*i).url)); 
    718729                } 
     
    722733                                i != e; ++i) 
    723734                { 
    724                         HAL_DEV_MSG(wformat_t(L"URL: %1%, port: %2%") % (*i).url % (*i).port); 
     735                        HAL_DEV_MSG(wformat(L"URL: %1%, port: %2%") % (*i).url % (*i).port); 
    725736                        t_info->add_node(hal::make_pair(to_utf8((*i).url), (*i).port)); 
    726737                } 
     
    748759                lbt::entry e = t_info->create_torrent(); 
    749760                halencode(out_file, e); 
    750         } 
    751         catch(const std::exception& e) 
    752         { 
    753                 event().post(shared_ptr<EventDetail>( 
    754                         new EventStdException(Event::fatal, e, L"create_torrent"))); 
    755         }        
    756         } 
    757          
    758         std::pair<lbt::entry, lbt::entry> prepTorrent(wpath_t filename, wpath_t saveDirectory); 
    759         void removalThread(TorrentInternal_ptr pIT, bool wipeFiles); 
     761                } 
     762                catch(const std::exception& e) 
     763                { 
     764                        event().post(shared_ptr<EventDetail>( 
     765                                new EventStdException(Event::fatal, e, L"create_torrent"))); 
     766                }        
     767        } 
     768         
     769        std::pair<lbt::entry, lbt::entry> prepTorrent(wpath filename, wpath saveDirectory); 
     770        void removalThread(torrent_internal_ptr pIT, bool wipeFiles); 
    760771         
    761772        lbt::session theSession; 
     
    764775        bool keepChecking_; 
    765776         
    766         static wpath_t workingDirectory; 
     777        static wpath workingDirectory; 
    767778        ini_file bittorrentIni; 
    768779        TorrentManager theTorrents;      
     
    790801}; 
    791802 
    792 wpath_t BitTorrent_impl::workingDirectory = hal::app().working_directory(); 
     803wpath BitTorrent_impl::workingDirectory = hal::app().working_directory(); 
    793804 
    794805BitTorrent::BitTorrent() : 
     
    828839} 
    829840 
     841BitTorrent::torrent BitTorrent::get_wstr(const std::wstring& filename) 
     842{ 
     843        return BitTorrent::torrent(pimpl->theTorrents.get(filename)); 
     844} 
     845 
    830846bool BitTorrent::listenOn(std::pair<int, int> const& range) 
    831847{ 
     
    957973 
    958974        event().post(shared_ptr<EventDetail>(new EventMsg( 
    959                 wformat_t(L"Set Timeouts, peer %1%, tracker %2%") % peers % tracker))); 
     975                wformat(L"Set Timeouts, peer %1%, tracker %2%") % peers % tracker))); 
    960976} 
    961977 
     
    966982         
    967983        event().post(shared_ptr<EventDetail>(new EventMsg( 
    968                 wformat_t(L"Set connections totals %1% and uploads %2%.")  
     984                wformat(L"Set connections totals %1% and uploads %2%.")  
    969985                        % maxConn % maxUpload))); 
    970986} 
     
    978994         
    979995        event().post(shared_ptr<EventDetail>(new EventMsg( 
    980                 wformat_t(L"Set session rates at download %1% and upload %2%.")  
     996                wformat(L"Set session rates at download %1% and upload %2%.")  
    981997                        % pimpl->theSession.download_rate_limit() % pimpl->theSession.upload_rate_limit()))); 
    982998} 
     
    10931109                        hal::event().post(shared_ptr<hal::EventDetail>( 
    10941110                                new hal::EventGeneral(hal::Event::warning, hal::Event::unclassified,  
    1095                                         (wformat_t(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str()))); 
     1111                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str()))); 
    10961112        } 
    10971113 
     
    11121128                        hal::event().post(shared_ptr<hal::EventDetail>( 
    11131129                                new hal::EventGeneral(hal::Event::warning, hal::Event::unclassified,  
    1114                                         (wformat_t(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
     1130                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    11151131        } 
    11161132 
     
    11311147                        hal::event().post(shared_ptr<hal::EventDetail>( 
    11321148                                new hal::EventGeneral(hal::Event::warning, hal::Event::unclassified,  
    1133                                         (wformat_t(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
     1149                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    11341150        } 
    11351151         
     
    12111227                boost::smatch m; 
    12121228                 
    1213                 string_t ip_address_line;                
     1229                string ip_address_line;          
    12141230                while (!std::getline(ifs, ip_address_line).eof()) 
    12151231                {                
     
    12271243                        if (boost::regex_match(ip_address_line, m, reg)) 
    12281244                        { 
    1229                                 string_t first = m[1]; 
    1230                                 string_t last = m[2]; 
     1245                                string first = m[1]; 
     1246                                string last = m[2]; 
    12311247                                 
    12321248                                if (octalFix) 
     
    12341250                                        if (boost::regex_match(first, m, ip_reg)) 
    12351251                                        { 
    1236                                                 first = ((m.length(1) != 0) ? m[1] : string_t("0")) + "." + 
    1237                                                                 ((m.length(2) != 0) ? m[2] : string_t("0")) + "." + 
    1238                                                                 ((m.length(3) != 0) ? m[3] : string_t("0")) + "." + 
    1239                                                                 ((m.length(4) != 0) ? m[4] : string_t("0")); 
     1252                                                first = ((m.length(1) != 0) ? m[1] : string("0")) + "." + 
     1253                                                                ((m.length(2) != 0) ? m[2] : string("0")) + "." + 
     1254                                                                ((m.length(3) != 0) ? m[3] : string("0")) + "." + 
     1255                                                                ((m.length(4) != 0) ? m[4] : string("0")); 
    12401256                                        }                                        
    12411257                                        if (boost::regex_match(last, m, ip_reg)) 
    12421258                                        { 
    1243                                                 last = ((m.length(1) != 0) ? m[1] : string_t("0")) + "." + 
    1244                                                            ((m.length(2) != 0) ? m[2] : string_t("0")) + "." + 
    1245                                                            ((m.length(3) != 0) ? m[3] : string_t("0")) + "." + 
    1246                                                            ((m.length(4) != 0) ? m[4] : string_t("0")); 
     1259                                                last = ((m.length(1) != 0) ? m[1] : string("0")) + "." + 
     1260                                                           ((m.length(2) != 0) ? m[2] : string("0")) + "." + 
     1261                                                           ((m.length(3) != 0) ? m[3] : string("0")) + "." + 
     1262                                                           ((m.length(4) != 0) ? m[4] : string("0")); 
    12471263                                        } 
    12481264                                } 
     
    12571273                                        hal::event().post(shared_ptr<hal::EventDetail>( 
    12581274                                                new hal::EventDebug(hal::Event::info,  
    1259                                                         from_utf8((format_t("Invalid IP range: %1%-%2%.") % first % last).str())))); 
     1275                                                        from_utf8((format("Invalid IP range: %1%-%2%.") % first % last).str())))); 
    12601276                                } 
    12611277                        } 
     
    12991315 
    13001316        event().post(shared_ptr<EventDetail>(new EventMsg( 
    1301                 wformat_t(L"Set half-open connections limit to %1%.") % pimpl->theSession.max_half_open_connections()))); 
     1317                wformat(L"Set half-open connections limit to %1%.") % pimpl->theSession.max_half_open_connections()))); 
    13021318} 
    13031319 
     
    13081324 
    13091325        event().post(shared_ptr<EventDetail>(new EventMsg( 
    1310                 wformat_t(L"Set torrent connections total %1% and uploads %2%.") % maxConn % maxUpload))); 
     1326                wformat(L"Set torrent connections total %1% and uploads %2%.") % maxConn % maxUpload))); 
    13111327 
    13121328        pimpl->defTorrentDownload_ = download; 
     
    13141330 
    13151331        event().post(shared_ptr<EventDetail>(new EventMsg( 
    1316                 wformat_t(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") % download % upload))); 
    1317 } 
    1318  
    1319 std::pair<lbt::entry, lbt::entry> BitTorrent_impl::prepTorrent(wpath_t filename, wpath_t saveDirectory) 
     1332                wformat(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") % download % upload))); 
     1333} 
     1334 
     1335std::pair<lbt::entry, lbt::entry> BitTorrent_impl::prepTorrent(wpath filename, wpath saveDirectory) 
    13201336{ 
    13211337        lbt::entry metadata = haldecode(filename); 
    13221338        lbt::torrent_info info(metadata); 
    13231339         
    1324         wstring_t torrentName = hal::from_utf8_safe(info.name()); 
     1340        wstring torrentName = hal::from_utf8_safe(info.name()); 
    13251341        if (!boost::find_last(torrentName, L".torrent"))  
    13261342                torrentName += L".torrent"; 
    13271343         
    1328         wpath_t torrentFilename = torrentName; 
    1329         const wpath_t resumeFile = workingDirectory/L"resume"/torrentFilename.leaf(); 
     1344        wpath torrentFilename = torrentName; 
     1345        const wpath resumeFile = workingDirectory/L"resume"/torrentFilename.leaf(); 
    13301346         
    13311347        //  vvv Handle old naming style! 
    1332         const wpath_t oldResumeFile = workingDirectory/L"resume"/filename.leaf(); 
     1348        const wpath oldResumeFile = workingDirectory/L"resume"/filename.leaf(); 
    13331349         
    13341350        if (filename.leaf() != torrentFilename.leaf() && exists(oldResumeFile)) 
     
    13651381} 
    13661382 
    1367 void BitTorrent::addTorrent(wpath_t file, wpath_t saveDirectory, bool startStopped, bool compactStorage,  
     1383void BitTorrent::addTorrent(wpath file, wpath saveDirectory, bool startStopped, bool compactStorage,  
    13681384                boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    13691385{ 
    13701386        try  
    13711387        {        
    1372         TorrentInternal_ptr TIp; 
     1388        torrent_internal_ptr TIp; 
    13731389 
    13741390        std::pair<std::string, std::string> names = extract_names(file); 
    1375         wstring_t xml_name = from_utf8(names.first) + L".xml"; 
     1391        wstring xml_name = from_utf8(names.first) + L".xml"; 
    13761392 
    13771393        if (fs::exists(file.branch_path()/xml_name)) 
     
    13861402        { 
    13871403                if (useMoveTo) 
    1388                         TIp.reset(new TorrentInternal(file, saveDirectory, compactStorage, moveToDirectory));            
     1404                        TIp.reset(new torrent_internal(file, saveDirectory, compactStorage, moveToDirectory));           
    13891405                else 
    1390                         TIp.reset(new TorrentInternal(file, saveDirectory, compactStorage)); 
     1406                        TIp.reset(new torrent_internal(file, saveDirectory, compactStorage)); 
    13911407 
    13921408                TIp->setTransferSpeed(bittorrent().defTorrentDownload(), bittorrent().defTorrentUpload()); 
     
    13991415        if (p.second) 
    14001416        { 
    1401                 TorrentInternal_ptr me = pimpl->theTorrents.get(TIp->name());            
     1417                torrent_internal_ptr me = pimpl->theTorrents.get(TIp->name());           
    14021418                 
    14031419                if (!startStopped)  
     
    14291445} 
    14301446 
    1431 void BitTorrent::newTorrent(wpath_t filename, wpath_t files) 
     1447void BitTorrent::newTorrent(wpath filename, wpath files) 
    14321448{ 
    14331449/*      try 
     
    14791495} 
    14801496 
    1481 const TorrentDetails& BitTorrent::updateTorrentDetails(const wstring_t& focused, const std::set<wstring_t>& selected) 
     1497const TorrentDetails& BitTorrent::updateTorrentDetails(const wstring& focused, const std::set<wstring>& selected) 
    14821498{ 
    14831499        try { 
     
    14901506        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e; ++i) 
    14911507        { 
    1492                 wstring_t utf8Name = (*i).torrent->name(); 
     1508                wstring utf8Name = (*i).torrent->name(); 
    14931509                TorrentDetail_ptr pT = (*i).torrent->getTorrentDetail_ptr(); 
    14941510                 
     
    15181534        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e;) 
    15191535        { 
    1520                 wpath_t file = wpath_t(pimpl->workingDirectory)/L"torrents"/(*i).torrent->filename(); 
     1536                wpath file = wpath(pimpl->workingDirectory)/L"torrents"/(*i).torrent->filename(); 
    15211537                 
    15221538                if (exists(file)) 
     
    15791595                if ((*i).torrent->inSession()) 
    15801596                { 
    1581                 //      HAL_DEV_MSG(wformat_t(L"Internalling pausing writeData=%1%") % writeData); 
     1597                //      HAL_DEV_MSG(wformat(L"Internalling pausing writeData=%1%") % writeData); 
    15821598                        (*i).torrent->handle().pause(); // Internal pause, not registered in Torrents.xml 
    15831599                } 
     
    16201636        client(hal::from_utf8_safe(peerInfo.client)) 
    16211637{ 
    1622         std::vector<wstring_t> status_vec; 
     1638        std::vector<wstring> status_vec; 
    16231639         
    16241640#ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES 
    16251641        if (peerInfo.country[0] != 0 && peerInfo.country[1] != 0) 
    1626                 country = (wformat_t(L"(%1%)") % hal::from_utf8_safe(string_t(peerInfo.country, 2))).str().c_str(); 
     1642                country = (wformat(L"(%1%)") % hal::from_utf8_safe(string(peerInfo.country, 2))).str().c_str(); 
    16271643#endif   
    16281644 
     
    18201836} 
    18211837 
    1822 void BitTorrent_impl::removalThread(TorrentInternal_ptr pIT, bool wipeFiles) 
     1838void BitTorrent_impl::removalThread(torrent_internal_ptr pIT, bool wipeFiles) 
    18231839{ 
    18241840        try { 
     
    18451861                                , end(m_info.end_files(true)); i != end; ++i) 
    18461862                        { 
    1847                                 std::string p = (hal::to_utf8(pIT->saveDirectory()) / i->path).string(); 
     1863                                std::string p = (hal::path_to_utf8(pIT->saveDirectory()) / i->path).string(); 
    18481864                                fs::path bp = i->path.branch_path(); 
    18491865                                 
     
    18531869                                { 
    18541870                                        std::pair<std::set<std::string>::iterator, bool> ret =  
    1855                                                 directories.insert((hal::to_utf8(pIT->saveDirectory()) / bp).string()); 
     1871                                                directories.insert((hal::path_to_utf8(pIT->saveDirectory()) / bp).string()); 
    18561872                                        bp = bp.branch_path(); 
    18571873                                } 
     
    18831899        try { 
    18841900         
    1885         TorrentInternal_ptr pTI = pimpl->theTorrents.get(filename); 
     1901        torrent_internal_ptr pTI = pimpl->theTorrents.get(filename); 
    18861902        lbt::torrent_handle handle = pTI->handle(); 
    18871903        pimpl->theTorrents.erase(filename); 
     
    19151931        try { 
    19161932         
    1917         TorrentInternal_ptr pTI = pimpl->theTorrents.get(filename); 
     1933        torrent_internal_ptr pTI = pimpl->theTorrents.get(filename); 
    19181934        lbt::torrent_handle handle = pTI->handle(); 
    19191935        pimpl->theTorrents.erase(filename); 
     
    19661982} 
    19671983 
    1968 void BitTorrent::torrent::set_ratio(float new_ratio) 
    1969 { 
    1970         try { 
    1971          
    1972         ptr->setRatio(ratio); 
     1984 
     1985BitTorrent::torrent::torrent(boost::shared_ptr<torrent_internal> p) : 
     1986        ptr(p) 
     1987{} 
     1988 
     1989BitTorrent::torrent::exec_around_ptr::proxy::proxy(torrent_internal* t) :  
     1990        t_(t), 
     1991        l_(t->mutex_) 
     1992{ 
     1993        HAL_DEV_MSG(L"Ctor proxy"); 
     1994} 
     1995 
     1996BitTorrent::torrent::exec_around_ptr::proxy::~proxy()  
     1997{ 
     1998        HAL_DEV_MSG(L"Dtor proxy"); 
     1999} 
     2000 
     2001float BitTorrent::torrent::get_ratio() const 
     2002{ 
     2003        try { 
     2004         
     2005        return ptr->get_ratio(); 
     2006         
     2007        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::get_ratio") 
     2008         
     2009        return 0; 
     2010} 
     2011 
     2012void BitTorrent::torrent::set_ratio(float r) 
     2013{ 
     2014        try { 
     2015 
     2016        ptr->set_ratio(r); 
    19732017         
    19742018        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::set_ratio") 
    19752019} 
    19762020 
    1977 float BitTorrent::torrent::get_ratio() const 
    1978 { 
    1979         try { 
    1980          
    1981         return ptr->getRatio(); 
    1982          
    1983         } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::get_ratio") 
    1984          
    1985         return 0; 
     2021wpath BitTorrent::torrent::get_save_directory() const 
     2022{ 
     2023        try { 
     2024         
     2025        return ptr->get_save_directory(); 
     2026         
     2027        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::get_save_directory") 
     2028         
     2029        return L""; 
     2030} 
     2031 
     2032void BitTorrent::torrent::set_save_directory(const wpath& s) 
     2033{ 
     2034        try { 
     2035         
     2036        ptr->set_save_directory(s); 
     2037         
     2038        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::set_save_directory") 
     2039} 
     2040 
     2041wpath BitTorrent::torrent::get_move_to_directory() const 
     2042{ 
     2043        try { 
     2044         
     2045        return ptr->get_move_to_directory(); 
     2046         
     2047        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::get_save_directory") 
     2048         
     2049        return L""; 
     2050} 
     2051 
     2052void BitTorrent::torrent::set_move_to_directory(const wpath& m) 
     2053{ 
     2054        try { 
     2055         
     2056        ptr->set_move_to_directory(m); 
     2057         
     2058        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(L"Me", "torrent::set_move_to_directory") 
    19862059} 
    19872060 
     
    19952068        try { 
    19962069         
    1997         pimpl->theTorrents.get(filename)->setRatio(ratio); 
     2070        pimpl->theTorrents.get(filename)->set_ratio(ratio); 
    19982071         
    19992072        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentRatio") 
     
    20092082        try { 
    20102083         
    2011         return pimpl->theTorrents.get(filename)->getRatio(); 
     2084        return pimpl->theTorrents.get(filename)->get_ratio(); 
    20122085         
    20132086        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentRatio") 
  • trunk/src/halTorrent.hpp

    r432 r437  
    411411 
    412412class BitTorrent_impl; 
    413 class TorrentInternal; 
     413class torrent_internal; 
    414414 
    415415class BitTorrent 
    416416{ 
     417public:  
     418 
    417419        class torrent 
    418420        { 
     
    420422 
    421423        public: 
     424                class exec_around_ptr 
     425                { 
     426                public: 
     427                        class proxy  
     428                        { 
     429                        public: 
     430                                explicit proxy(torrent_internal* t); 
     431 
     432                                torrent_internal* operator->()  
     433                                { 
     434                                        return t_; 
     435                                } 
     436 
     437                                ~proxy (); 
     438 
     439                        private: 
     440                                torrent_internal* t_; 
     441                                mutex_t::scoped_lock l_; 
     442                        }; 
     443 
     444                        exec_around_ptr(boost::shared_ptr<torrent_internal> p) : ptr(p) {} 
     445 
     446                        proxy operator->() const 
     447                        { 
     448                                return proxy(&(*ptr)); 
     449                        } 
     450 
     451                private: 
     452                        boost::shared_ptr<torrent_internal> ptr; 
     453                }; 
     454 
     455                torrent(boost::shared_ptr<torrent_internal> p); 
     456 
     457                float get_ratio() const; 
    422458                void set_ratio(float new_ratio); 
    423                 float get_ratio() const; 
     459 
     460                wpath get_save_directory() const; 
     461                void set_save_directory(const wpath&); 
     462                wpath get_move_to_directory() const; 
     463                void set_move_to_directory(const wpath&); 
    424464 
    425465        public: 
    426466                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(float, float, class_type,  
    427467                        get_ratio, set_ratio, ratio); 
     468                 
     469                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type,  
     470                        get_save_directory, set_save_directory, save_directory); 
     471                STLSOFT_METHOD_PROPERTY_GETSET_EXTERNAL(wpath, const wpath&, class_type,  
     472                        get_move_to_directory, set_move_to_directory, move_to_directory); 
    428473 
    429474        private: 
    430                 boost::shared_ptr<TorrentInternal> ptr; 
     475                exec_around_ptr ptr; 
    431476        }; 
    432477 
    433 public:  
    434478        enum mappings 
    435479        { 
     
    443487 
    444488        void create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn); 
     489 
     490        template<typename T> 
     491        torrent get(T t) 
     492        { 
     493                return get_wstr(to_wstr_shim(t)); 
     494        } 
     495 
     496        torrent get_wstr(const std::wstring& filename); 
    445497         
    446498        bool listenOn(std::pair<int, int> const& portRange); 
  • trunk/src/halTorrentInternal.hpp

    r431 r437  
    8383 
    8484#include "halIni.hpp" 
     85#include "halTypes.hpp" 
    8586#include "halSignaler.hpp" 
    8687 
     
    8889{ 
    8990class TorrentInternalOld; 
    90 class TorrentInternal; 
     91class torrent_internal; 
    9192} 
    9293 
    9394BOOST_CLASS_VERSION(hal::TorrentInternalOld, 9) 
    94 BOOST_CLASS_VERSION(hal::TorrentInternal, 2) 
     95BOOST_CLASS_VERSION(hal::torrent_internal, 2) 
    9596 
    9697namespace hal  
     
    9899 
    99100namespace lbt = libtorrent; 
    100 namespace fs = boost::filesystem; 
    101 namespace pt = boost::posix_time; 
    102  
    103 typedef std::wstring wstring_t; 
    104 typedef std::string string_t; 
    105  
    106 typedef boost::wformat wformat_t; 
    107 typedef boost::format format_t; 
    108  
    109 typedef boost::filesystem::wpath wpath_t; 
    110 typedef boost::filesystem::path path_t; 
    111  
    112 using boost::serialization::make_nvp; 
    113 using boost::shared_ptr; 
    114 using boost::bind; 
    115  
    116 lbt::entry haldecode(const wpath_t &file)  
     101 
     102lbt::entry haldecode(const wpath &file)  
    117103{ 
    118104        fs::ifstream ifs(file, fs::ifstream::binary); 
     
    125111} 
    126112 
    127 bool halencode(const wpath_t &file, const lbt::entry &e)  
     113bool halencode(const wpath &file, const lbt::entry &e)  
    128114{ 
    129115        fs::ofstream ofs(file, fs::ofstream::binary); 
     
    136122} 
    137123 
    138 std::pair<std::string, std::string> extract_names(const wpath_t &file) 
     124inline path path_to_utf8(const wpath& wp) 
     125{ 
     126        return path(to_utf8(wp.string())); 
     127} 
     128 
     129inline wpath path_from_utf8(const path& p) 
     130{ 
     131        return wpath(from_utf8(p.string())); 
     132} 
     133 
     134std::pair<std::string, std::string> extract_names(const wpath &file) 
    139135{ 
    140136        if (fs::exists(file))  
     
    149145                 
    150146                event().post(shared_ptr<EventDetail>(new EventMsg( 
    151                         wformat_t(L"Loaded names: %1%, %2%") % from_utf8(name) % from_utf8(filename)))); 
     147                        wformat(L"Loaded names: %1%, %2%") % from_utf8(name) % from_utf8(filename)))); 
    152148 
    153149                return std::make_pair(name, filename); 
     
    160156{ 
    161157public: 
    162         invalidTorrent(const wstring_t& who) : 
     158        invalidTorrent(const wstring& who) : 
    163159                who_(who) 
    164160        {} 
     
    166162        virtual ~invalidTorrent() throw () {} 
    167163 
    168         wstring_t who() const throw () 
     164        wstring who() const throw () 
    169165        { 
    170166                return who_; 
     
    172168         
    173169private: 
    174         wstring_t who_;  
     170        wstring who_;    
    175171}; 
    176172         
     
    219215        void serialize(Archive& ar, const unsigned int version) 
    220216        { 
    221                 ar & make_nvp("total", total_); 
     217                ar & slz::make_nvp("total", total_); 
    222218        } 
    223219         
     
    256252        void serialize(Archive& ar, const unsigned int version) 
    257253        { 
    258                 ar & make_nvp("total", total_); 
     254                ar & slz::make_nvp("total", total_); 
    259255        } 
    260256         
     
    273269    void serialize(Archive& ar, const unsigned int version) 
    274270    { 
    275         ar & make_nvp("transferLimit", transferLimit_); 
    276         ar & make_nvp("connections", connections_); 
    277         ar & make_nvp("uploads", uploads_);      
     271        ar & slz::make_nvp("transferLimit", transferLimit_); 
     272        ar & slz::make_nvp("connections", connections_); 
     273        ar & slz::make_nvp("uploads", uploads_);         
    278274                 
    279275                if (version > 6) { 
    280                         ar & make_nvp("filename", filename_); 
     276                        ar & slz::make_nvp("filename", filename_); 
    281277                } 
    282278                else  
    283279                { 
    284                         wstring_t originalFilename; 
    285                         ar & make_nvp("filename", originalFilename); 
     280                        wstring originalFilename; 
     281                        ar & slz::make_nvp("filename", originalFilename); 
    286282                         
    287283                        updatePreVersion7Files(originalFilename); 
    288284                } 
    289285                 
    290         ar & make_nvp("saveDirectory", save_directory_); 
     286        ar & slz::make_nvp("saveDirectory", save_directory_); 
    291287                 
    292288                if (version > 7) { 
    293                         ar & make_nvp("payloadUploaded_", payloadUploaded_); 
    294                         ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
    295                         ar & make_nvp("uploaded_", uploaded_); 
    296                         ar & make_nvp("downloaded_", downloaded_);       
    297                         ar & make_nvp("ratio", ratio_);  
     289                        ar & slz::make_nvp("payloadUploaded_", payloadUploaded_); 
     290                        ar & slz::make_nvp("payloadDownloaded_", payloadDownloaded_); 
     291                        ar & slz::make_nvp("uploaded_", uploaded_); 
     292                        ar & slz::make_nvp("downloaded_", downloaded_);  
     293                        ar & slz::make_nvp("ratio", ratio_);     
    298294                }  
    299295                else if (version > 3) { 
    300                         ar & make_nvp("payloadUploaded_", payloadUploaded_); 
    301                         ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
    302                         ar & make_nvp("uploaded_", uploaded_); 
    303                         ar & make_nvp("downloaded_", downloaded_);               
     296                        ar & slz::make_nvp("payloadUploaded_", payloadUploaded_); 
     297                        ar & slz::make_nvp("payloadDownloaded_", payloadDownloaded_); 
     298                        ar & slz::make_nvp("uploaded_", uploaded_); 
     299                        ar & slz::make_nvp("downloaded_", downloaded_);          
    304300                }  
    305301                else if (version > 1) 
    306302                { 
    307                         ar & make_nvp("totalUploaded", totalUploaded_); 
    308                         ar & make_nvp("ratio", ratio_); 
     303                        ar & slz::make_nvp("totalUploaded", totalUploaded_); 
     304                        ar & slz::make_nvp("ratio", ratio_); 
    309305                         
    310306                        payloadUploaded_.reset(totalUploaded_); 
     
    312308                 
    313309                if (version > 0) { 
    314                         ar & make_nvp("trackerUsername", trackerUsername_); 
    315                         ar & make_nvp("trackerPassword", trackerPassword_); 
     310                        ar & slz::make_nvp("trackerUsername", trackerUsername_); 
     311                        ar & slz::make_nvp("trackerPassword", trackerPassword_); 
    316312                } 
    317313                if (version > 1) { 
    318                         ar & make_nvp("state", state_); 
    319                         ar & make_nvp("trackers", trackers_); 
     314                        ar & slz::make_nvp("state", state_); 
     315                        ar & slz::make_nvp("trackers", trackers_); 
    320316                } 
    321317         
    322318                if (version > 2) { 
    323                         ar & make_nvp("resolve_countries", resolve_countries_); 
     319                        ar & slz::make_nvp("resolve_countries", resolve_countries_); 
    324320                } 
    325321                if (version > 4) { 
    326                         ar & make_nvp("file_priorities", filePriorities_); 
     322                        ar & slz::make_nvp("file_priorities", filePriorities_); 
    327323                } 
    328324                if (version > 5) { 
    329                         ar & make_nvp("startTime", startTime_); 
    330                         ar & make_nvp("activeDuration", activeDuration_); 
    331                         ar & make_nvp("seedingDuration", seedingDuration_); 
     325                        ar & slz::make_nvp("startTime", startTime_); 
     326                        ar & slz::make_nvp("activeDuration", activeDuration_); 
     327                        ar & slz::make_nvp("seedingDuration", seedingDuration_); 
    332328                } 
    333329                if (version > 6) { 
    334                         ar & make_nvp("name", name_); 
    335                         ar & make_nvp("compactStorage", compactStorage_); 
    336                         ar & make_nvp("finishTime", finishTime_); 
     330                        ar & slz::make_nvp("name", name_); 
     331                        ar & slz::make_nvp("compactStorage", compactStorage_); 
     332                        ar & slz::make_nvp("finishTime", finishTime_); 
    337333                } 
    338334                if (version > 8) { 
    339                         ar & make_nvp("progress", progress_); 
     335                        ar & slz::make_nvp("progress", progress_); 
    340336                } 
    341337    } 
     
    351347                 
    352348                event().post(shared_ptr<EventDetail>(new EventMsg( 
    353                         wformat_t(L"Loaded names: %1%, %2%") % name_ % filename_))); 
    354         } 
    355          
    356         void updatePreVersion7Files(wstring_t originalFilename) 
     349                        wformat(L"Loaded names: %1%, %2%") % name_ % filename_))); 
     350        } 
     351         
     352        void updatePreVersion7Files(wstring originalFilename) 
    357353        { 
    358354                try  
    359355                { 
    360356 
    361                 wpath_t oldFile = app().working_directory()/L"torrents"/originalFilename; 
     357                wpath oldFile = app().working_directory()/L"torrents"/originalFilename; 
    362358                 
    363359                if (fs::exists(oldFile))  
    364360                        extractNames(haldecode(oldFile)); 
    365361                 
    366                 wpath_t oldResumeFile = app().working_directory()/L"resume"/originalFilename; 
     362                wpath oldResumeFile = app().working_directory()/L"resume"/originalFilename; 
    367363                 
    368364                if (filename_ != originalFilename) 
     
    391387        bool resolve_countries_; 
    392388         
    393         wstring_t filename_; 
    394         wstring_t name_; 
    395         wstring_t save_directory_; 
    396         wstring_t originalFilename_; 
     389        wstring filename_; 
     390        wstring name_; 
     391        wstring save_directory_; 
     392        wstring originalFilename_; 
    397393        lbt::torrent_handle handle_;     
    398394         
     
    400396        lbt::entry resumedata_; 
    401397         
    402         wstring_t trackerUsername_;      
    403         wstring_t trackerPassword_; 
     398        wstring trackerUsername_;        
     399        wstring trackerPassword_; 
    404400         
    405401        boost::int64_t totalUploaded_; 
     
    438434 
    439435 
    440 class TorrentInternal; 
    441 typedef shared_ptr<TorrentInternal> TorrentInternal_ptr; 
     436class torrent_internal; 
     437typedef shared_ptr<torrent_internal> torrent_internal_ptr; 
    442438 
    443439struct torrent_standalone : 
     
    451447        {} 
    452448 
    453         torrent_standalone(TorrentInternal_ptr t) : 
     449        torrent_standalone(torrent_internal_ptr t) : 
    454450                iniClass("torrent"), 
    455451                torrent(t), 
     
    457453        {} 
    458454 
    459         TorrentInternal_ptr torrent; 
     455        torrent_internal_ptr torrent; 
    460456        pt::ptime save_time; 
    461457 
     
    464460    void serialize(Archive& ar, const unsigned int version) 
    465461    { 
    466         ar & make_nvp("torrent", torrent); 
    467         ar & make_nvp("save_time", save_time); 
     462                ar & slz::make_nvp("torrent", torrent); 
     463                ar & slz::make_nvp("save_time", save_time); 
    468464    } 
    469465}; 
    470466 
    471 class TorrentInternal : 
    472         public boost::enable_shared_from_this<TorrentInternal>, 
     467class torrent_internal : 
     468        public boost::enable_shared_from_this<torrent_internal>, 
    473469        private boost::noncopyable 
    474470{ 
    475471        friend class BitTorrent_impl;    
     472        friend class BitTorrent::torrent::exec_around_ptr::proxy; 
     473 
    476474public: 
    477475        #define TORRENT_INTERNALS_DEFAULTS \ 
     
    488486                in_session_(false) 
    489487                 
    490         TorrentInternal() :      
     488        torrent_internal() :     
    491489                TORRENT_INTERNALS_DEFAULTS, 
    492490                compactStorage_(true), 
     
    494492        {} 
    495493         
    496         TorrentInternal(wpath_t filename, wpath_t saveDirectory, bool compactStorage, wpath_t move_to_directory=L"") : 
     494        torrent_internal(wpath filename, wpath saveDirectory, bool compactStorage, wpath move_to_directory=L"") : 
    497495                TORRENT_INTERNALS_DEFAULTS, 
    498496                save_directory_(saveDirectory.string()), 
     
    505503        } 
    506504         
    507         TorrentInternal(const TorrentInternalOld& t) : 
     505        torrent_internal(const TorrentInternalOld& t) : 
    508506                transferLimit_(t.transferLimit_), 
    509507                state_(t.state_), 
     
    550548        std::pair<int, int> getConnectionLimit(); 
    551549         
    552         const wstring_t& name() const { return name_; } 
    553          
    554         void setRatio(float ratio)  
     550        const wstring& name() const { return name_; } 
     551         
     552        void set_ratio(float ratio)  
    555553        {  
    556554                if (ratio < 0) ratio = 0; 
    557555                ratio_ = ratio;  
    558556                 
    559                 applyRatio(); 
    560         } 
    561          
    562         float getRatio() 
     557                apply_ratio(); 
     558        } 
     559         
     560        float get_ratio() 
    563561        { 
    564562                return ratio_; 
     
    573571                assert(the_session_ != 0); 
    574572 
    575                 HAL_DEV_MSG(wformat_t(L"addToSession() paused=%1%") % paused); 
     573                HAL_DEV_MSG(wformat(L"addToSession() paused=%1%") % paused); 
    576574                 
    577575                if (!inSession())  
    578576                {                        
    579                         string_t dir = to_utf8(save_directory_); 
     577                        path dir = path_to_utf8(save_directory_); 
    580578                         
    581579                        lbt::storage_mode_t storage = lbt::storage_mode_sparse; 
     
    618616                assert(inSession()); 
    619617 
    620                 HAL_DEV_MSG(wformat_t(L"removeFromSession() writeData=%1%") % writeData); 
     618                HAL_DEV_MSG(wformat(L"removeFromSession() writeData=%1%") % writeData); 
    621619                 
    622620                if (writeData) 
     
    689687                        handle_.pause(); 
    690688                        signals().torrent_paused.disconnect_all_once(); 
    691                         signals().torrent_paused.connect_once(bind(&TorrentInternal::completed_pause, this)); 
     689                        signals().torrent_paused.connect_once(bind(&torrent_internal::completed_pause, this)); 
    692690 
    693691                        state_ = TorrentDetail::torrent_pausing;         
     
    706704 
    707705                                signals().torrent_paused.disconnect_all_once(); 
    708                                 signals().torrent_paused.connect_once(bind(&TorrentInternal::completed_stop, this)); 
     706                                signals().torrent_paused.connect_once(bind(&torrent_internal::completed_stop, this)); 
    709707                                handle_.pause(); 
    710708 
     
    742740                case TorrentDetail::torrent_active: 
    743741                        signals().torrent_paused.disconnect_all_once(); 
    744                         signals().torrent_paused.connect_once(bind(&TorrentInternal::handle_recheck, this)); 
     742                        signals().torrent_paused.connect_once(bind(&torrent_internal::handle_recheck, this)); 
    745743                        handle_.pause(); 
    746744                        state_ = TorrentDetail::torrent_pausing; 
     
    755753        {                                        
    756754                HAL_DEV_MSG(L"writeResumeData()"); 
    757                 wpath_t resumeDir = workingDir_/L"resume"; 
     755                wpath resumeDir = workingDir_/L"resume"; 
    758756                 
    759757                if (!exists(resumeDir)) 
     
    767765        void clearResumeData() 
    768766        { 
    769                 wpath_t resumeFile = workingDir_/L"resume"/filename_; 
     767                wpath resumeFile = workingDir_/L"resume"/filename_; 
    770768                 
    771769                if (exists(resumeFile)) 
     
    774772                resumedata_ = lbt::entry(); 
    775773        } 
     774 
     775        const wpath get_save_directory() 
     776        { 
     777                return save_directory_; 
     778        } 
     779 
     780        void set_save_directory(wpath s) 
     781        { 
     782                if (inSession() && !is_finished() && 
     783                                s != path_from_utf8(handle_.save_path())) 
     784                { 
     785                        handle_.move_storage(path_to_utf8(s)); 
     786                        save_directory_ = s; 
     787                } 
     788        } 
     789 
     790        const wpath get_move_to_directory() 
     791        { 
     792                return move_to_directory_; 
     793        } 
     794         
     795        void set_move_to_directory(wpath m) 
     796        { 
     797                if (is_finished() && !m.empty()) 
     798                { 
     799                        if (m != path_from_utf8(handle_.save_path())) 
     800                        { 
     801                                handle_.move_storage(path_to_utf8(m)); 
     802                                save_directory_ = move_to_directory_ = m; 
     803                        } 
     804                } 
     805                else 
     806                { 
     807                        move_to_directory_ = m; 
     808                } 
     809        } 
     810 
     811        bool is_finished() 
     812        { 
     813                if (inSession()) 
     814                { 
     815                        lbt::torrent_status::state_t s = handle_.status().state; 
     816 
     817                        return (s == lbt::torrent_status::seeding || 
     818                                                s == lbt::torrent_status::finished); 
     819                } 
     820                else return false; 
     821        } 
    776822         
    777823        void finished() 
     
    780826                        finishTime_ = boost::posix_time::second_clock::universal_time(); 
    781827 
    782                 // Only move seeding torrents for the mo! 
    783                 if (inSession() && handle_.status().state == lbt::torrent_status::seeding) 
    784                 { 
    785                         if (move_to_directory_ != L"" && move_to_directory_ != save_directory_) 
     828                if (is_finished()) 
     829                { 
     830                        if (!move_to_directory_.empty() &&  
     831                                        move_to_directory_ !=  path_from_utf8(handle_.save_path())) 
    786832                        { 
    787                                 handle_.move_storage(to_utf8(move_to_directory_)); 
     833                                handle_.move_storage(path_to_utf8(move_to_directory_)); 
    788834                                save_directory_ = move_to_directory_; 
    789835                        } 
     
    795841        unsigned state() const { return state_; } 
    796842         
    797         void setTrackerLogin(wstring_t username, wstring_t password) 
     843        void setTrackerLogin(wstring username, wstring password) 
    798844        { 
    799845                trackerUsername_ = username; 
     
    803849        }        
    804850         
    805         std::pair<wstring_t, wstring_t> getTrackerLogin() const 
     851        std::pair<wstring, wstring> getTrackerLogin() const 
    806852        { 
    807853                return make_pair(trackerUsername_, trackerPassword_); 
    808854        } 
    809855         
    810         const wstring_t& filename() const { return filename_; } 
    811          
    812         const wstring_t& originalFilename() const { return originalFilename_; } 
     856        const wstring& filename() const { return filename_; } 
     857         
     858        const wstring& originalFilename() const { return originalFilename_; } 
    813859         
    814860        const lbt::torrent_handle& handle() const { return handle_; } 
     
    857903        } 
    858904 
    859         const wstring_t& saveDirectory() { return save_directory_; } 
     905        const wpath& saveDirectory() { return save_directory_; } 
    860906         
    861907    friend class boost::serialization::access; 
     
    864910    { 
    865911                if (version > 1) { 
    866                         ar & make_nvp("transfer_limits", transferLimit_); 
    867                         ar & make_nvp("connection_limits", connections_); 
    868                         ar & make_nvp("upload_limits", uploads_);        
    869  
    870                         ar & make_nvp("name", name_); 
    871                         ar & make_nvp("filename", filename_);    
    872  
    873                         ar & make_nvp("ratio", ratio_);  
    874                         ar & make_nvp("progress", progress_); 
    875                         ar & make_nvp("state", state_); 
    876                         ar & make_nvp("compact_storage", compactStorage_);       
    877                         ar & make_nvp("resolve_countries", resolve_countries_);  
    878  
    879                         ar & make_nvp("tracker_username", trackerUsername_); 
    880                         ar & make_nvp("tracker_password", trackerPassword_); 
    881                         ar & make_nvp("trackers", trackers_); 
    882  
    883                         ar & make_nvp("save_directory", save_directory_); 
    884                         ar & make_nvp("move_to_directory", move_to_directory_); 
    885                          
    886                         ar & make_nvp("payload_uploaded", payloadUploaded_); 
    887                         ar & make_nvp("payload_downloaded", payloadDownloaded_); 
    888                         ar & make_nvp("uploaded", uploaded_); 
    889                         ar & make_nvp("downloaded", downloaded_);                        
     912                        ar & slz::make_nvp("transfer_limits", transferLimit_); 
     913                        ar & slz::make_nvp("connection_limits", connections_); 
     914                        ar & slz::make_nvp("upload_limits", uploads_);   
     915 
     916                        ar & slz::make_nvp("name", name_); 
     917                        ar & slz::make_nvp("filename", filename_);       
     918 
     919                        ar & slz::make_nvp("ratio", ratio_);     
     920                        ar & slz::make_nvp("progress", progress_); 
     921                        ar & slz::make_nvp("state", state_); 
     922                        ar & slz::make_nvp("compact_storage", compactStorage_);  
     923                        ar & slz::make_nvp("resolve_countries", resolve_countries_);     
     924 
     925                        ar & slz::make_nvp("tracker_username", trackerUsername_); 
     926                        ar & slz::make_nvp("tracker_password", trackerPassword_); 
     927                        ar & slz::make_nvp("trackers", trackers_); 
     928 
     929                        ar & slz::make_nvp("save_directory", save_directory_); 
     930                        ar & slz::make_nvp("move_to_directory", move_to_directory_); 
     931                         
     932                        ar & slz::make_nvp("payload_uploaded", payloadUploaded_); 
     933                        ar & slz::make_nvp("payload_downloaded", payloadDownloaded_); 
     934                        ar & slz::make_nvp("uploaded", uploaded_); 
     935                        ar & slz::make_nvp("downloaded", downloaded_);                   
    890936                                         
    891                         ar & make_nvp("file_priorities", filePriorities_); 
    892                          
    893                         ar & make_nvp("start_time", startTime_); 
    894                         ar & make_nvp("finish_time", finishTime_); 
    895                         ar & make_nvp("active_duration", activeDuration_); 
    896                         ar & make_nvp("seeding_duration", seedingDuration_); 
     937                        ar & slz::make_nvp("file_priorities", filePriorities_); 
     938                         
     939                        ar & slz::make_nvp("start_time", startTime_); 
     940                        ar & slz::make_nvp("finish_time", finishTime_); 
     941                        ar & slz::make_nvp("active_duration", activeDuration_); 
     942                        ar & slz::make_nvp("seeding_duration", seedingDuration_); 
    897943                                         
    898944                }  
    899945                else  
    900946                { 
    901                     ar & make_nvp("transferLimit", transferLimit_); 
    902                         ar & make_nvp("connections", connections_); 
    903                         ar & make_nvp("uploads", uploads_);                      
    904                         ar & make_nvp("filename", filename_);            
    905                         ar & make_nvp("saveDirectory", save_directory_); 
     947                    ar & slz::make_nvp("transferLimit", transferLimit_); 
     948                        ar & slz::make_nvp("connections", connections_); 
     949                        ar & slz::make_nvp("uploads", uploads_);                         
     950                        ar & slz::make_nvp("filename", filename_);       
     951                        if (version == 0) { 
     952                                wstring s; 
     953                                ar & slz::make_nvp("saveDirectory", save_directory_); 
     954                                save_directory_ = s; 
     955                        } else {                                 
     956                                ar & slz::make_nvp("saveDirectory", save_directory_); 
     957                        } 
     958 
    906959                        if (version > 0) { 
    907                                 ar & make_nvp("moveToDirectory", move_to_directory_); 
     960                                wstring m; 
     961                                ar & slz::make_nvp("moveToDirectory", m); 
     962                                move_to_directory_ = m; 
    908963                        } else { 
    909964                                move_to_directory_ = save_directory_; 
    910965                        } 
    911966                         
    912                         ar & make_nvp("payloadUploaded_", payloadUploaded_); 
    913                         ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
    914                         ar & make_nvp("uploaded_", uploaded_); 
    915                         ar & make_nvp("downloaded_", downloaded_);       
    916                         ar & make_nvp("ratio", ratio_);  
    917                         ar & make_nvp("trackerUsername", trackerUsername_); 
    918                         ar & make_nvp("trackerPassword", trackerPassword_); 
    919                          
    920                         ar & make_nvp("state", state_); 
    921                         ar & make_nvp("trackers", trackers_); 
    922                          
    923                         ar & make_nvp("resolve_countries", resolve_countries_); 
    924                          
    925                         ar & make_nvp("file_priorities", filePriorities_); 
    926                          
    927                         ar & make_nvp("startTime", startTime_); 
    928                         ar & make_nvp("activeDuration", activeDuration_); 
    929                         ar & make_nvp("seedingDuration", seedingDuration_); 
    930                          
    931                         ar & make_nvp("name", name_); 
    932                         ar & make_nvp("compactStorage", compactStorage_); 
    933                         ar & make_nvp("finishTime", finishTime_); 
    934                          
    935                         ar & make_nvp("progress", progress_); 
     967                        ar & slz::make_nvp("payloadUploaded_", payloadUploaded_); 
     968                        ar & slz::make_nvp("payloadDownloaded_", payloadDownloaded_); 
     969                        ar & slz::make_nvp("uploaded_", uploaded_); 
     970                        ar & slz::make_nvp("downloaded_", downloaded_);  
     971                        ar & slz::make_nvp("ratio", ratio_);     
     972                        ar & slz::make_nvp("trackerUsername", trackerUsername_); 
     973                        ar & slz::make_nvp("trackerPassword", trackerPassword_); 
     974                         
     975                        ar & slz::make_nvp("state", state_); 
     976                        ar & slz::make_nvp("trackers", trackers_); 
     977                         
     978                        ar & slz::make_nvp("resolve_countries", resolve_countries_); 
     979                         
     980                        ar & slz::make_nvp("file_priorities", filePriorities_); 
     981                         
     982                        ar & slz::make_nvp("startTime", startTime_); 
     983                        ar & slz::make_nvp("activeDuration", activeDuration_); 
     984                        ar & slz::make_nvp("seedingDuration", seedingDuration_); 
     985                         
     986                        ar & slz::make_nvp("name", name_); 
     987                        ar & slz::make_nvp("compactStorage", compactStorage_); 
     988                        ar & slz::make_nvp("finishTime", finishTime_); 
     989                         
     990                        ar & slz::make_nvp("progress", progress_); 
    936991        } 
    937992    } 
     
    10071062                        for(size_t i=0, e=files.size(); i<e; ++i) 
    10081063                        { 
    1009                                 wstring_t fullPath = hal::from_utf8(files[i].path.string()); 
     1064                                wstring fullPath = hal::from_utf8(files[i].path.string()); 
    10101065                                boost::int64_t size = static_cast<boost::int64_t>(files[i].size); 
    10111066                                 
     
    10291084        } 
    10301085         
    1031         void prepare(wpath_t filename) 
     1086        void prepare(wpath filename) 
    10321087        { 
    10331088                mutex_t::scoped_lock l(mutex_); 
     
    10381093                extractNames(metadata_);                         
    10391094                 
    1040                 const wpath_t resumeFile = workingDir_/L"resume"/filename_; 
    1041                 const wpath_t torrentFile = workingDir_/L"torrents"/filename_; 
     1095                const wpath resumeFile = workingDir_/L"resume"/filename_; 
     1096                const wpath torrentFile = workingDir_/L"torrents"/filename_; 
    10421097                 
    10431098                event().post(shared_ptr<EventDetail>(new EventMsg( 
    1044                         wformat_t(L"File: %1%, %2%.") % resumeFile % torrentFile))); 
     1099                        wformat(L"File: %1%, %2%.") % resumeFile % torrentFile))); 
    10451100                 
    10461101                if (exists(resumeFile))  
     
    10741129                 
    10751130                event().post(shared_ptr<EventDetail>(new EventMsg( 
    1076                         wformat_t(L"Loaded names: %1%, %2%") % name_ % filename_))); 
     1131                        wformat(L"Loaded names: %1%, %2%") % name_ % filename_))); 
    10771132        } 
    10781133         
     
    10971152                applyTransferSpeed(); 
    10981153                applyConnectionLimit(); 
    1099                 applyRatio(); 
     1154                apply_ratio(); 
    11001155                applyTrackers(); 
    11011156                applyTrackerLogin(); 
     
    11151170                        handle_.set_upload_limit(up); 
    11161171 
    1117                         HAL_DEV_MSG(wformat_t(L"Applying Transfer Speed %1% - %2%") % down % up); 
     1172                        HAL_DEV_MSG(wformat(L"Applying Transfer Speed %1% - %2%") % down % up); 
    11181173                } 
    11191174        } 
     
    11271182                        handle_.set_max_uploads(uploads_); 
    11281183 
    1129                         HAL_DEV_MSG(wformat_t(L"Applying Connection Limit %1% - %2%") % connections_ % uploads_); 
    1130                 } 
    1131         } 
    1132          
    1133         void applyRatio() 
     1184                        HAL_DEV_MSG(wformat(L"Applying Connection Limit %1% - %2%") % connections_ % uploads_); 
     1185                } 
     1186        } 
     1187         
     1188        void apply_ratio() 
    11341189        {  
    11351190                mutex_t::scoped_lock l(mutex_); 
     
    11381193                        handle_.set_ratio(ratio_); 
    11391194 
    1140                         HAL_DEV_MSG(wformat_t(L"Applying Ratio %1%") % ratio_); 
     1195                        HAL_DEV_MSG(wformat(L"Applying Ratio %1%") % ratio_); 
    11411196                } 
    11421197        } 
     
    11781233                        } 
    11791234 
    1180                         HAL_DEV_MSG(wformat_t(L"Applying Tracker Login User: %1%, Pass: %2%") % trackerUsername_ % trackerPassword_ ); 
     1235                        HAL_DEV_MSG(wformat(L"Applying Tracker Login User: %1%, Pass: %2%") % trackerUsername_ % trackerPassword_ ); 
    11811236                } 
    11821237        } 
     
    12011256                        handle_.resolve_countries(resolve_countries_); 
    12021257                         
    1203                         HAL_DEV_MSG(wformat_t(L"Applying Resolve Countries %1%") % resolve_countries_); 
     1258                        HAL_DEV_MSG(wformat(L"Applying Resolve Countries %1%") % resolve_countries_); 
    12041259                } 
    12051260        } 
     
    12471302                 
    12481303        static lbt::session* the_session_; 
    1249         static wpath_t workingDir_; 
     1304        static wpath workingDir_; 
    12501305         
    12511306        mutable mutex_t mutex_; 
     
    12601315        bool resolve_countries_; 
    12611316         
    1262         wstring_t filename_; 
    1263         wstring_t name_; 
    1264         wstring_t save_directory_; 
    1265         wstring_t move_to_directory_; 
    1266         wstring_t originalFilename_; 
     1317        wstring filename_; 
     1318        wstring name_; 
     1319        wpath save_directory_; 
     1320        wpath move_to_directory_; 
     1321        wstring originalFilename_; 
    12671322        lbt::torrent_handle handle_;     
    12681323         
     
    12701325        lbt::entry resumedata_; 
    12711326         
    1272         wstring_t trackerUsername_;      
    1273         wstring_t trackerPassword_; 
     1327        wstring trackerUsername_;        
     1328        wstring trackerPassword_; 
    12741329         
    12751330        boost::int64_t totalUploaded_; 
     
    13111366        struct TorrentHolder 
    13121367        { 
    1313                 mutable TorrentInternal_ptr torrent; 
    1314                  
    1315                 wstring_t filename; 
    1316                 wstring_t name;          
     1368                mutable torrent_internal_ptr torrent; 
     1369                 
     1370                wstring filename; 
     1371                wstring name;            
    13171372                 
    13181373                TorrentHolder() 
    13191374                {} 
    13201375                 
    1321                 explicit TorrentHolder(TorrentInternal_ptr t) : 
     1376                explicit TorrentHolder(torrent_internal_ptr t) : 
    13221377                        torrent(t), filename(torrent->filename()), name(torrent->name()) 
    13231378                {} 
     
    13301385                        { 
    13311386                                TorrentInternalOld t; 
    1332                                 ar & make_nvp("torrent", t); 
     1387                                ar & slz::make_nvp("torrent", t); 
    13331388                                 
    1334                                 torrent.reset(new TorrentInternal(t)); 
     1389                                torrent.reset(new torrent_internal(t)); 
    13351390                        } 
    13361391                        else 
    13371392                        { 
    1338                                 ar & make_nvp("torrent", torrent); 
     1393                                ar & slz::make_nvp("torrent", torrent); 
    13391394                        }  
    13401395                         
    1341                         ar & make_nvp("filename", filename); 
    1342                         ar & make_nvp("name", name); 
     1396                        ar & slz::make_nvp("filename", filename); 
     1397                        ar & slz::make_nvp("name", name); 
    13431398                } 
    13441399        }; 
     
    13531408                                boost::multi_index::tag<byFilename>, 
    13541409                                boost::multi_index::member< 
    1355                                         TorrentHolder, wstring_t, &TorrentHolder::filename>  
     1410                                        TorrentHolder, wstring, &TorrentHolder::filename>  
    13561411                                >, 
    13571412                        boost::multi_index::ordered_unique< 
    13581413                                boost::multi_index::tag<byName>, 
    13591414                                boost::multi_index::member< 
    1360                                         TorrentHolder, wstring_t, &TorrentHolder::name>  
     1415                                        TorrentHolder, wstring, &TorrentHolder::name>  
    13611416                                > 
    13621417                > 
     
    13771432                for (TorrentMap::const_iterator i=map.begin(), e=map.end(); i != e; ++i) 
    13781433                {        
    1379                         TorrentInternal_ptr TIp(new TorrentInternal((*i).second)); 
     1434                        torrent_internal_ptr TIp(new torrent_internal((*i).second)); 
    13801435                         
    13811436                        event().post(shared_ptr<EventDetail>(new EventMsg( 
    1382                                 wformat_t(L"Converting %1%.") % TIp->name()))); 
     1437                                wformat(L"Converting %1%.") % TIp->name()))); 
    13831438                         
    13841439                        torrents_.insert(TorrentHolder(TIp)); 
     
    13931448        } 
    13941449         
    1395         std::pair<torrentByName::iterator, bool> insert(TorrentInternal_ptr t) 
     1450        std::pair<torrentByName::iterator, bool> insert(torrent_internal_ptr t) 
    13961451        { 
    13971452                return insert(TorrentHolder(t)); 
    13981453        } 
    13991454 
    1400         TorrentInternal_ptr getByFile(const wstring_t& filename) 
     1455        torrent_internal_ptr getByFile(const wstring& filename) 
    14011456        { 
    14021457                torrentByFilename::iterator it = torrents_.get<byFilename>().find(filename); 
     
    14101465        } 
    14111466         
    1412         TorrentInternal_ptr get(const wstring_t& name) 
     1467        torrent_internal_ptr get(const wstring& name) 
    14131468        { 
    14141469                torrentByName::iterator it = torrents_.get<byName>().find(name); 
     
    14321487        } 
    14331488         
    1434         size_t erase(const wstring_t& name) 
     1489        size_t erase(const wstring& name) 
    14351490        { 
    14361491                return torrents_.get<byName>().erase(name); 
    14371492        } 
    14381493         
    1439         bool exists(const wstring_t& name) 
     1494        bool exists(const wstring& name) 
    14401495        { 
    14411496                torrentByName::iterator it = torrents_.get<byName>().find(name); 
     
    14541509        void serialize(Archive& ar, const unsigned int version) 
    14551510        { 
    1456                 ar & make_nvp("torrents", torrents_); 
     1511                ar & slz::make_nvp("torrents", torrents_); 
    14571512        }        
    14581513         
     
    14611516}; 
    14621517 
    1463 void TorrentInternal::setConnectionLimit(int maxConn, int maxUpload) 
     1518void torrent_internal::setConnectionLimit(int maxConn, int maxUpload) 
    14641519{ 
    14651520        mutex_t::scoped_lock l(mutex_); 
     
    14711526} 
    14721527 
    1473 std::pair<int, int> TorrentInternal::getConnectionLimit() 
     1528std::pair<int, int> torrent_internal::getConnectionLimit() 
    14741529{ 
    14751530        return std::make_pair(connections_, uploads_); 
    14761531} 
    14771532 
    1478 void TorrentInternal::setTransferSpeed(float download, float upload) 
     1533void torrent_internal::setTransferSpeed(float download, float upload) 
    14791534{        
    14801535        mutex_t::scoped_lock l(mutex_); 
     
    14851540} 
    14861541 
    1487 std::pair<float, float> TorrentInternal::getTransferSpeed() 
     1542std::pair<float, float> torrent_internal::getTransferSpeed() 
    14881543{ 
    14891544        return transferLimit_; 
    14901545} 
    14911546 
    1492 TorrentDetail_ptr TorrentInternal::getTorrentDetail_ptr() 
     1547TorrentDetail_ptr torrent_internal::getTorrentDetail_ptr() 
    14931548{        
    14941549        mutex_t::scoped_lock l(mutex_); 
     
    15111566        } 
    15121567         
    1513         wstring_t state; 
     1568        wstring state; 
    15141569         
    15151570        switch (state_) 
     
    15871642        boost::tuple<size_t, size_t, size_t, size_t> connections = updatePeers();                
    15881643 
    1589         return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory(), state, hal::from_utf8(statusMemory_.current_tracker),  
     1644        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), state, hal::from_utf8(statusMemory_.current_tracker),  
    15901645                std::pair<float, float>(statusMemory_.download_payload_rate, statusMemory_.upload_payload_rate), 
    15911646                progress_, statusMemory_.distributed_copies, statusMemory_.total_wanted_done, statusMemory_.total_wanted, uploaded_, payloadUploaded_, 
     
    16041659        } 
    16051660         
    1606         return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA))); 
     1661        return TorrentDetail_ptr(new TorrentDetail(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA))); 
    16071662} 
    16081663 
  • trunk/src/halTypes.hpp

    r429 r437  
    1717        namespace pt = boost::posix_time; 
    1818        namespace xp = boost::xpressive; 
    19         namespace sl = boost::serialization; 
     19        namespace slz = boost::serialization; 
     20 
     21        using std::wstring; 
     22        using std::string; 
    2023 
    2124        using std::pair; 
    2225        using std::make_pair;    
    23         using boost::tuple; 
    2426 
    2527        typedef boost::int64_t size_type; 
    2628        typedef boost::recursive_mutex mutex_t; 
    2729        typedef boost::thread thread_t; 
     30 
     31        using boost::tuple; 
     32        using boost::shared_ptr; 
     33        using boost::bind; 
     34 
     35        using boost::wformat; 
     36        using boost::format; 
     37 
     38        using fs::wpath; 
     39        using fs::path; 
    2840} 
Note: See TracChangeset for help on using the changeset viewer.