Changeset 110


Ignore:
Timestamp:
12/26/06 16:53:56 (13 years ago)
Author:
Eoin
Message:

Just prior to deleting "ini/Torrent.hpp".

Location:
src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • src/GlobalIni.cpp

    r107 r110  
     1 
     2#include "stdAfx.hpp" 
    13 
    24#include <boost/array.hpp> 
     5#include <boost/filesystem/fstream.hpp>   
    36 
    47#include "GlobalIni.hpp" 
     
    811#include "ini/Window.hpp" 
    912#include "ini/BitTConfig.hpp" 
    10 #include "ini/Torrent.hpp" 
     13//#include "ini/Torrent.hpp" 
    1114#include "ini/Splash.hpp" 
    1215 
     
    2326        haliteWindow_(new WindowConfig()), 
    2427        haliteDialog_(new DialogConfig()), 
    25         torrentConfig_(new halite::TorrentConfig()), 
     28//      torrentConfig_(new halite::TorrentConfig()), 
    2629        generalConfig_(new GeneralConfig()), 
    2730        remoteConfig_(new RemoteConfig()), 
     
    5558                        ia >> make_nvp("remoteConfig", *remoteConfig_); 
    5659                        ia >> make_nvp("splashConfig", *splashConfig_); 
    57                         ia >> make_nvp("torrentConfig", *torrentConfig_); 
     60//                      ia >> make_nvp("torrentConfig", *torrentConfig_); 
    5861                } 
    5962                return true; 
     
    8487                oa << make_nvp("remoteConfig", *remoteConfig_);  
    8588                oa << make_nvp("splashConfig", *splashConfig_); 
    86                 oa << make_nvp("torrentConfig", *torrentConfig_);                        
     89//              oa << make_nvp("torrentConfig", *torrentConfig_);                        
    8790                return true; 
    8891        } 
  • src/GlobalIni.hpp

    r109 r110  
    22#pragma once 
    33 
    4 #include "stdAfx.hpp" 
     4//#include "stdAfx.hpp" 
    55 
    66#include <boost/smart_ptr.hpp> 
     
    1616class SplashConfig; 
    1717 
    18 namespace halite 
    19 { 
    20 class TorrentConfig; 
    21 }; 
     18//namespace halite 
     19//{ 
     20//class TorrentConfig; 
     21//}; 
    2222 
    2323class ArchivalData 
     
    3333        WindowConfig& windowConfig() { return *haliteWindow_; } 
    3434        DialogConfig& dialogConfig() { return *haliteDialog_; } 
    35         halite::TorrentConfig& torrentConfig() { return *torrentConfig_; } 
     35//      halite::TorrentConfig& torrentConfig() { return *torrentConfig_; } 
    3636         
    3737        const boost::filesystem::path& workingFile() { return workingFile_; } 
     
    4848        boost::scoped_ptr<WindowConfig> haliteWindow_; 
    4949        boost::scoped_ptr<DialogConfig> haliteDialog_; 
    50         boost::scoped_ptr<halite::TorrentConfig> torrentConfig_; 
     50//      boost::scoped_ptr<halite::TorrentConfig> torrentConfig_; 
    5151         
    5252        boost::filesystem::path workingFile_; 
  • src/HaliteDialog.cpp

    r108 r110  
    88#include "HaliteWindow.hpp" 
    99 
    10 #include "HaliteListViewCtrl.hpp" 
    11  
    1210#include "GlobalIni.hpp" 
    1311#include "ini/Dialog.hpp" 
    1412 
    15 void HaliteDialog::selectionChanged() 
    16 { 
    17         string torrentName = mainHaliteWindow->getSelected(); 
    18          
     13HaliteDialog::HaliteDialog(ui_signal& ui_sig, single_selection_manager& single_sel) : 
     14        ui_(ui_sig), 
     15        single_selection_(single_sel) 
     16{ 
     17        ui_.attach(bind(&HaliteDialog::updateDialog, this)); 
     18        single_selection_.attach(bind(&HaliteDialog::selectionChanged, this, _1)); 
     19} 
     20 
     21void HaliteDialog::selectionChanged(const string& torrent_name) 
     22{        
    1923        pair<float, float> tranLimit(-1.0, -1.0); 
    2024        pair<int, int> connLimit(-1, -1); 
    21                  
    22         if (halite::bittorrent().isTorrent(torrentName)) 
    23         { 
    24                 tranLimit = halite::bittorrent().getTorrentSpeed(torrentName); 
    25                 connLimit = halite::bittorrent().getTorrentLimit(torrentName); 
    26                  
    27                 if (halite::bittorrent().isTorrentPaused(torrentName)) 
     25         
     26        if (halite::bittorrent().isTorrent(torrent_name)) 
     27        { 
     28                tranLimit = halite::bittorrent().getTorrentSpeed(torrent_name); 
     29                connLimit = halite::bittorrent().getTorrentLimit(torrent_name); 
     30                 
     31                if (halite::bittorrent().isTorrentPaused(torrent_name)) 
    2832                        SetDlgItemText(BTNPAUSE, L"Resume"); 
    2933                else             
     
    6872         
    6973        m_list.DeleteAllItems();         
    70         mainHaliteWindow->updateUI(); 
     74        ui_.update(); 
    7175} 
    7276 
     
    110114void HaliteDialog::onClose() 
    111115{ 
    112         if(::IsWindow(m_hWnd)) { 
     116        if(::IsWindow(m_hWnd))  
     117        { 
    113118                ::DestroyWindow(m_hWnd); 
    114119        } 
     
    117122void HaliteDialog::onPause(UINT, int, HWND) 
    118123{ 
    119         string torrentName = mainHaliteWindow->getSelected(); 
     124        string torrentName = single_selection_.selected(); 
    120125        if (halite::bittorrent().isTorrentPaused(torrentName)) 
    121126        { 
     
    129134        } 
    130135         
    131         mainHaliteWindow->updateUI(); 
     136        ui_.update(); 
    132137} 
    133138 
    134139void HaliteDialog::onReannounce(UINT, int, HWND) 
    135140{ 
    136         halite::bittorrent().reannounceTorrent(mainHaliteWindow->getSelected()); 
     141        halite::bittorrent().reannounceTorrent(single_selection_.selected()); 
    137142} 
    138143 
    139144void HaliteDialog::onRemove(UINT, int, HWND) 
    140145{ 
    141         mainHaliteWindow->clearSelected();               
    142          
    143         mainHaliteWindow->updateUI(); 
     146        single_selection_.clear();               
     147         
     148        ui_.update(); 
    144149} 
    145150 
     
    148153        DoDataExchange(true); 
    149154         
    150         halite::bittorrent().setTorrentSpeed(mainHaliteWindow->getSelected(), TranLimitDown, TranLimitUp); 
    151         halite::bittorrent().setTorrentLimit(mainHaliteWindow->getSelected(), NoConnDown, NoConnUp); 
     155        halite::bittorrent().setTorrentSpeed(single_selection_.selected(), TranLimitDown, TranLimitUp); 
     156        halite::bittorrent().setTorrentLimit(single_selection_.selected(), NoConnDown, NoConnUp); 
    152157         
    153158        return 0; 
     
    158163        ::SetTextColor(hDC, RGB(255, 0, 255));  
    159164         
    160         return (LRESULT)::GetStockObject(DC_BRUSH); 
     165        return (LRESULT)::GetCurrentObject(hDC, OBJ_BRUSH); 
    161166} 
    162167 
     
    164169{ 
    165170        halite::TorrentDetail_ptr pTD = halite::bittorrent().getTorrentDetails( 
    166                 mainHaliteWindow->getSelected()); 
     171                single_selection_.selected()); 
    167172         
    168173        if (pTD)         
     
    190195                 
    191196                halite::PeerDetails peerDetails; 
    192                 halite::bittorrent().getAllPeerDetails(mainHaliteWindow->getSelected(), peerDetails); 
     197                halite::bittorrent().getAllPeerDetails(single_selection_.selected(), peerDetails); 
    193198                 
    194199                if (!peerDetails.empty()) 
  • src/HaliteDialog.hpp

    r108 r110  
    66#include "Halite.hpp" 
    77 
    8 class HaliteWindow; 
     8class ui_signal; 
     9class single_selection_manager; 
    910 
    1011class HaliteDialog : 
    1112        public CDialogImpl<HaliteDialog>, 
    1213        public CDialogResize<HaliteDialog>, 
    13         public CWinDataExchangeEx<HaliteDialog> 
     14        public CWinDataExchangeEx<HaliteDialog>, 
     15        private noncopyable 
    1416{ 
    1517protected: 
     
    2123        enum { IDD = IDD_HALITEDLG }; 
    2224         
    23         HaliteDialog(HaliteWindow* halWnd) 
    24                 : mainHaliteWindow(halWnd) 
    25         {} 
    26  
    27         BOOL PreTranslateMessage(MSG* pMsg) 
    28         { 
    29                 return this->IsDialogMessage(pMsg); 
    30         } 
     25        HaliteDialog(ui_signal& ui_sig, single_selection_manager& single_sel);   
     26        BOOL PreTranslateMessage(MSG* pMsg)     { return this->IsDialogMessage(pMsg); } 
     27         
     28        void saveStatus(); // ****** NEEDS TO BE ANOTHER SIGNAL CLASS ****** 
    3129         
    3230        BEGIN_MSG_MAP(thisClass) 
     
    4240                COMMAND_ID_HANDLER_EX(BTNREMOVE, onRemove) 
    4341                 
    44 //              MSG_WM_CTLCOLORSTATIC(OnCltColor) 
     42        //      MSG_WM_CTLCOLORSTATIC(OnCltColor) 
    4543                 
    4644                CHAIN_MSG_MAP(resizeClass) 
     
    8280        END_DLGRESIZE_MAP() 
    8381         
     82protected:       
    8483        LRESULT onInitDialog(HWND, LPARAM);      
    8584        void onClose();  
     
    9291        LRESULT OnCltColor(HDC hDC, HWND hWnd); 
    9392         
    94         void selectionChanged();         
     93        void selectionChanged(const string& torrent_name);       
    9594        void updateDialog(); 
    96         void saveStatus(); 
    97          
    98 protected: 
    99         void InitializeControls(void); 
    100         void InitializeValues(void); 
    10195 
     96private: 
    10297        CButton m_btn_start; 
    10398        CListViewCtrl m_list; 
     
    108103        float TranLimitDown, TranLimitUp; 
    109104         
    110         HaliteWindow* mainHaliteWindow;  
     105        ui_signal& ui_; 
     106        single_selection_manager& single_selection_; 
    111107}; 
  • src/HaliteListViewCtrl.hpp

    r97 r110  
    44#include "stdAfx.hpp" 
    55 
    6 class HaliteListViewCtrl : public CWindowImpl<HaliteListViewCtrl, CListViewCtrl> 
     6class HaliteListViewCtrl :  
     7        public CWindowImpl<HaliteListViewCtrl, CListViewCtrl>, 
     8        private noncopyable 
    79{ 
    810public:  
  • src/HaliteWindow.cpp

    r109 r110  
    1717#include "ini/Window.hpp" 
    1818 
     19void single_selection_manager::sync_with_list(bool list_to_manager) 
     20{ 
     21        if (list_to_manager) 
     22        {        
     23                int itemPos = mp_list_->GetSelectionMark();              
     24                if (itemPos != -1) 
     25                { 
     26                        boost::array<wchar_t, MAX_PATH> pathBuffer; 
     27                        mp_list_->GetItemText(itemPos, 0, pathBuffer.c_array(), pathBuffer.size());      
     28                        string selected = wcstombs(pathBuffer.data()); 
     29                         
     30                        if (selected_ != selected) 
     31                        { 
     32                                selected_ = selected; 
     33                                signal(); 
     34                        } 
     35                } 
     36                else 
     37                { 
     38                        selected_ = ""; 
     39                        signal(); 
     40                } 
     41        } 
     42        else 
     43        { 
     44                LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };  
     45                findInfo.flags = LVFI_STRING; 
     46                 
     47                wstring torrent_name = mbstowcs(selected_);              
     48                findInfo.psz = torrent_name.c_str(); 
     49                 
     50                int itemPos = mp_list_->FindItem(&findInfo, -1);         
     51                 
     52                if (itemPos != mp_list_->GetSelectionMark()) 
     53                { 
     54                        mp_list_->SelectItem(itemPos); 
     55                        signal(); 
     56                } 
     57        } 
     58} 
     59 
     60void single_selection_manager::setSelected(int itemPos) 
     61{ 
     62        mp_list_->SelectItem(itemPos); 
     63        sync_with_list(true); 
     64} 
     65 
     66void single_selection_manager::clear() 
     67{ 
     68        mp_list_->DeleteItem(mp_list_->GetSelectionMark()); 
     69        halite::bittorrent().removeTorrent(selected_); 
     70         
     71        mp_list_->SelectItem(0); 
     72        sync_with_list(true); 
     73} 
     74 
    1975HaliteWindow::HaliteWindow(unsigned areYouMe = 0) : 
    2076        mp_list(new HaliteListViewCtrl()), 
    21         mp_dlg(new HaliteDialog(this)), 
     77        single_selection_manager_(mp_list), 
    2278        WM_AreYouMe_(areYouMe) 
    2379{} 
     
    87143                LVS_REPORT|LVS_SINGLESEL|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|LVS_SHOWSELALWAYS); 
    88144         
     145        mp_dlg.reset(new HaliteDialog(ui(), selection())), 
    89146        mp_dlg->Create(m_Split.m_hWnd); 
    90147        mp_dlg->ShowWindow(true); 
     
    109166        // Register UIEvents and the timer for the monitoring interval 
    110167        SetTimer(ID_UPDATE_TIMER, 500); 
    111         attachUIEvent(bind(&HaliteWindow::updateWindow, this)); 
    112         attachUIEvent(bind(&HaliteListViewCtrl::updateListView, &*mp_list)); 
    113         attachUIEvent(bind(&HaliteDialog::updateDialog, &*mp_dlg)); 
     168        ui().attach(bind(&HaliteWindow::updateWindow, this)); 
     169        ui().attach(bind(&HaliteListViewCtrl::updateListView, &*mp_list)); 
    114170         
    115171        RegisterDropTarget(); 
     
    121177        pLoop->AddIdleHandler(this); 
    122178         
    123         updateUI(); 
    124         setSelected(0); 
    125         selectionChanged(); 
    126          
    127         return 0; 
    128 } 
    129  
    130 const string& HaliteWindow::getSelected() const  
     179        selection().setSelected(0); 
     180        ui().update(); 
     181         
     182        return 0; 
     183} 
     184 
     185/*const string& HaliteWindow::getSelected() const  
    131186{ 
    132187        return selectedTorrent_;  
     
    161216        mp_dlg->selectionChanged(); 
    162217} 
    163  
     218*/ 
    164219LRESULT HaliteWindow::OnNotify(int wParam, LPNMHDR lParam) 
    165220{ 
    166221        if (lParam->hwndFrom == *mp_list && lParam->code == NM_CLICK) 
    167222        { 
    168                 selectionChanged(); 
     223                selection().sync_with_list(true); 
    169224        } 
    170225        return 0; 
     
    218273        if (uTimerID == ID_UPDATE_TIMER)  
    219274        { 
    220                 updateUI(); 
     275                ui().update(); 
    221276        } 
    222277        else  
     
    248303        halite::bittorrent().addTorrent(file, globalModule().exePath().branch_path()/"incoming"); 
    249304 
    250         updateUI(); 
     305        ui().update(); 
    251306         
    252307        int itemPos = mp_list->GetSelectionMark(); 
     
    260315                 
    261316                int itemPos = mp_list->FindItem(&findInfo, -1);  
    262                 mp_list->SelectItem(itemPos); 
    263                 selectionChanged(); 
     317                selection().setSelected(itemPos); 
    264318        }        
    265319         
     
    358412                path(wcstombs(files),boost::filesystem::native)); 
    359413         
    360         updateUI(); 
     414        ui().update(); 
    361415         
    362416        return 0; 
     
    376430{ 
    377431        halite::bittorrent().pauseAllTorrents(); 
    378         updateUI(); 
     432        ui().update(); 
    379433        return 0; 
    380434} 
     
    383437{ 
    384438        halite::bittorrent().resumeAllTorrents(); 
    385         updateUI(); 
     439        ui().update(); 
    386440        return 0; 
    387441} 
  • src/HaliteWindow.hpp

    r107 r110  
    1313class AdvHaliteDialog; 
    1414 
     15class ui_signal : noncopyable 
     16{ 
     17public: 
     18        void attach(boost::function<void ()> fn) { ui_.connect(fn); } 
     19        void update() { ui_(); } 
     20         
     21private: 
     22        boost::signal<void ()> ui_; 
     23}; 
     24 
     25class single_selection_manager : noncopyable 
     26{ 
     27public: 
     28        single_selection_manager(boost::shared_ptr<HaliteListViewCtrl> p_list) : 
     29                mp_list_(p_list) 
     30        {} 
     31        typedef const string& param_type; 
     32         
     33        void sync_with_list(bool list_to_manager); 
     34         
     35        param_type selected() const { return selected_; } 
     36         
     37        void setSelected(const string& sel)  
     38        { 
     39                selected_ = sel; 
     40                sync_with_list(false); 
     41        } 
     42         
     43        void setSelected(int itemPos); 
     44         
     45        void clear(); 
     46         
     47        void attach(boost::function<void (param_type)> fn) { selection_.connect(fn); } 
     48        void signal() { selection_(selected_); } 
     49         
     50private: 
     51        string selected_;        
     52        boost::signal<void (param_type)> selection_; 
     53        boost::shared_ptr<HaliteListViewCtrl> mp_list_; 
     54}; 
     55 
     56class config_signal 
     57{ 
     58public: 
     59        void attach(boost::function<void (bool)> fn) { config_.connect(fn); } 
     60        void update(bool firstTime) { config_(firstTime); } 
     61         
     62private: 
     63        boost::signal<void (bool)> config_; 
     64}; 
     65 
    1566class HaliteWindow :  
    1667        public CFrameWindowImpl<HaliteWindow>, 
     
    1869        public CDropFileTarget<HaliteWindow>, 
    1970        public CMessageFilter, 
    20         public CIdleHandler 
     71        public CIdleHandler, 
     72        private noncopyable 
    2173{ 
    2274public:  
    2375        HaliteWindow(unsigned ARE_YOU_ME); 
    2476        ~HaliteWindow(); 
     77 
     78        DECLARE_FRAME_WND_CLASS(NULL, IDR_MAINFRAME); 
    2579         
     80        ui_signal& ui() { return ui_; } 
     81        single_selection_manager& selection() { return single_selection_manager_; } 
     82 
     83        BEGIN_MSG_MAP(HaliteWindow) 
     84                MSG_WM_NOTIFY(OnNotify) 
     85                MSG_WM_CREATE(OnCreate) 
     86                MSG_WM_CLOSE(OnClose) 
     87                MSG_WM_SIZE(OnSize) 
     88                MSG_WM_MOVE(OnMove) 
     89                MSG_WM_ERASEBKGND(OnEraseBkgnd) 
     90                MSG_WM_TIMER(OnTimer)    
     91                MSG_WM_COPYDATA(OnCopyData); 
     92                MESSAGE_HANDLER(WM_AreYouMe_, OnAreYouMe)        
     93                MESSAGE_HANDLER_EX(WM_TRAYNOTIFY, OnTrayNotification) 
     94                 
     95                COMMAND_ID_HANDLER(ID_FILE_NEW, OnFileNew) 
     96                COMMAND_ID_HANDLER(ID_FILE_OPEN, OnFileOpen) 
     97                COMMAND_ID_HANDLER(ID_RESUME, OnResumeAll) 
     98                COMMAND_ID_HANDLER(ID_PAUSE, OnPauseAll) 
     99                COMMAND_ID_HANDLER(ID_SETTINGS, OnSettings) 
     100                COMMAND_ID_HANDLER(ID_HELP, OnHelp) 
     101                COMMAND_ID_HANDLER(ID_VIEW_STATUS_BAR, OnViewStatusBar) 
     102                COMMAND_ID_HANDLER(ID_TRAY_OPENHALITE, OnTrayOpenHalite) 
     103                COMMAND_ID_HANDLER(ID_TRAY_EXIT, OnTrayExit) 
     104                 
     105                CHAIN_MSG_MAP(CUpdateUI<HaliteWindow>) 
     106                CHAIN_MSG_MAP(CFrameWindowImpl<HaliteWindow>) 
     107                CHAIN_MSG_MAP(CDropFileTarget<HaliteWindow>) 
     108        END_MSG_MAP() 
     109         
     110        BEGIN_UPDATE_UI_MAP(HaliteWindow) 
     111                UPDATE_ELEMENT(ID_VIEW_TOOLBAR, UPDUI_MENUPOPUP) 
     112                UPDATE_ELEMENT(IDR_TRAY_MENU, UPDUI_MENUPOPUP) 
     113                 
     114                UPDATE_ELEMENT(ID_VIEW_STATUS_BAR, UPDUI_MENUPOPUP) 
     115        UPDATE_ELEMENT(0, UPDUI_STATUSBAR) 
     116        UPDATE_ELEMENT(1, UPDUI_STATUSBAR) 
     117        UPDATE_ELEMENT(2, UPDUI_STATUSBAR) 
     118        END_UPDATE_UI_MAP() 
     119         
     120        void ProcessFile(LPCTSTR lpszPath); 
     121 
     122protected: 
    26123        virtual BOOL PreTranslateMessage(MSG* pMsg); 
    27124         
     
    36133                ID_UPDATE_TIMER = 1, 
    37134                WM_TRAYNOTIFY = WM_USER+123 
    38         }; 
    39          
    40         DECLARE_FRAME_WND_CLASS(NULL, IDR_MAINFRAME); 
    41          
    42         BEGIN_MSG_MAP(HaliteWindow) 
    43                 MSG_WM_NOTIFY(OnNotify) 
    44                 MSG_WM_CREATE(OnCreate) 
    45                 MSG_WM_CLOSE(OnClose) 
    46                 MSG_WM_SIZE(OnSize) 
    47                 MSG_WM_MOVE(OnMove) 
    48                 MSG_WM_ERASEBKGND(OnEraseBkgnd) 
    49                 MSG_WM_TIMER(OnTimer)    
    50                 MSG_WM_COPYDATA(OnCopyData); 
    51                 MESSAGE_HANDLER(WM_AreYouMe_, OnAreYouMe)        
    52                 MESSAGE_HANDLER_EX(WM_TRAYNOTIFY, OnTrayNotification) 
    53                 COMMAND_ID_HANDLER(ID_FILE_NEW, OnFileNew) 
    54                 COMMAND_ID_HANDLER(ID_FILE_OPEN, OnFileOpen) 
    55                 COMMAND_ID_HANDLER(ID_RESUME, OnResumeAll) 
    56                 COMMAND_ID_HANDLER(ID_PAUSE, OnPauseAll) 
    57                 COMMAND_ID_HANDLER(ID_SETTINGS, OnSettings) 
    58                 COMMAND_ID_HANDLER(ID_HELP, OnHelp) 
    59                 COMMAND_ID_HANDLER(ID_VIEW_STATUS_BAR, OnViewStatusBar) 
    60                 COMMAND_ID_HANDLER(ID_TRAY_OPENHALITE, OnTrayOpenHalite) 
    61                 COMMAND_ID_HANDLER(ID_TRAY_EXIT, OnTrayExit) 
    62                 CHAIN_MSG_MAP(CUpdateUI<HaliteWindow>) 
    63                 CHAIN_MSG_MAP(CFrameWindowImpl<HaliteWindow>) 
    64                 CHAIN_MSG_MAP(CDropFileTarget<HaliteWindow>) 
    65         END_MSG_MAP() 
    66          
    67         BEGIN_UPDATE_UI_MAP(HaliteWindow) 
    68                 UPDATE_ELEMENT(ID_VIEW_TOOLBAR, UPDUI_MENUPOPUP) 
    69                 UPDATE_ELEMENT(ID_VIEW_STATUS_BAR, UPDUI_MENUPOPUP) 
    70                 UPDATE_ELEMENT(IDR_TRAY_MENU, UPDUI_MENUPOPUP) 
    71         UPDATE_ELEMENT(0, UPDUI_STATUSBAR) 
    72         UPDATE_ELEMENT(1, UPDUI_STATUSBAR) 
    73         UPDATE_ELEMENT(2, UPDUI_STATUSBAR) 
    74         END_UPDATE_UI_MAP() 
    75          
     135        };       
     136 
    76137        LRESULT OnUpdateUIInfo(UINT, WPARAM, LPARAM, BOOL&); 
    77138        LRESULT HaliteWindow::OnNotify(int wParam, LPNMHDR lParam); 
     
    98159        LRESULT OnAreYouMe(UINT, WPARAM, LPARAM, BOOL&) { return WM_AreYouMe_; } 
    99160         
    100         void attachUIEvent(boost::function<void ()> fn) { updateUI_.connect(fn); } 
    101         void updateUI() { updateUI_(); } 
     161        void updateWindow(); 
    102162         
    103         void updateWindow(); 
    104         void ProcessFile(LPCTSTR lpszPath); 
    105          
    106         const string& getSelected() const; 
    107         void setSelected(int index); 
    108         void selectionChanged(); 
    109         void clearSelected(); 
    110          
    111         friend HaliteDialog; 
    112         friend HaliteListViewCtrl; 
    113          
    114 protected:               
     163//      const string& getSelected() const; 
     164//      void setSelected(int index); 
     165//      void selectionChanged(); 
     166//      void clearSelected(); 
     167 
     168private:                 
    115169        CCommandBarCtrl m_CmdBar; 
    116170        CHorSplitterWindow m_Split; 
     
    118172        CTrayNotifyIcon m_trayIcon; 
    119173         
    120         boost::scoped_ptr<HaliteListViewCtrl> mp_list; 
     174        boost::shared_ptr<HaliteListViewCtrl> mp_list; 
    121175        boost::scoped_ptr<HaliteDialog> mp_dlg; 
    122176        boost::scoped_ptr<AdvHaliteDialog> mp_advDlg; 
     177 
     178        ui_signal ui_; 
     179        config_signal config_; 
     180        single_selection_manager single_selection_manager_; 
    123181         
    124         boost::signal<void ()> updateUI_; 
    125         string selectedTorrent_; 
     182//      boost::signal<void ()> updateSelection_; 
     183         
     184//      string selectedTorrent_; 
    126185        unsigned WM_AreYouMe_; 
    127186         
  • src/halTorrent.cpp

    r107 r110  
    66#include <iterator> 
    77#include <iomanip> 
     8#include <map> 
     9 
     10#include <boost/bind.hpp> 
    811#include <boost/array.hpp> 
     12#include <boost/archive/xml_oarchive.hpp> 
     13#include <boost/archive/xml_iarchive.hpp> 
     14#include <boost/serialization/map.hpp> 
     15#include <boost/serialization/split_free.hpp> 
    916 
    1017#include <libtorrent/file.hpp> 
    11 #include "libtorrent/hasher.hpp" 
     18#include <libtorrent/hasher.hpp> 
    1219#include <libtorrent/entry.hpp> 
    1320#include <libtorrent/bencode.hpp> 
     
    1724 
    1825#include "halTorrent.hpp" 
    19 #include "GlobalIni.hpp" 
    20 #include "ini/Torrent.hpp" 
     26//#include "GlobalIni.hpp" 
     27//#include "ini/Torrent.hpp" 
    2128 
    2229namespace halite  
     
    2936using fs::ifstream; 
    3037using fs::ofstream; 
     38using boost::serialization::make_nvp; 
     39 
     40class TorrentInternal 
     41{ 
     42public: 
     43        TorrentInternal() :              
     44                transferLimit_(std::pair<float, float>(-1, -1)), 
     45                connections_(-1), 
     46                uploads_(-1), 
     47                paused_(false), 
     48                inSession_(false) 
     49        {} 
     50         
     51        TorrentInternal(libtorrent::torrent_handle h, std::wstring f, path saveDirectory) :              
     52                transferLimit_(std::pair<float, float>(-1, -1)), 
     53                connections_(-1), 
     54                uploads_(-1), 
     55                paused_(false), 
     56                filename_(f), 
     57                saveDirectory_(saveDirectory.string()), 
     58                inSession_(true), 
     59                handle_(h) 
     60        {} 
     61         
     62        TorrentDetail_ptr getTorrentDetails() const; 
     63        void setTransferSpeed(float down, float up); 
     64        void setConnectionLimit(int maxConn, int maxUpload); 
     65        void setTransferSpeed(); 
     66        void setConnectionLimit(); 
     67        pair<float, float> getTransferSpeed(); 
     68        pair<int, int> getConnectionLimit(); 
     69        void pause(); 
     70        void resume(); 
     71        bool isPaused() const; 
     72         
     73        const libtorrent::torrent_handle& handle() const { return handle_; } 
     74        void setHandle(libtorrent::torrent_handle h)  
     75        {  
     76                handle_ = h;  
     77                inSession_ = true; 
     78        }         
     79         
     80        bool inSession() const { return inSession_; } 
     81        const string& saveDirectory() { return saveDirectory_; } 
     82         
     83    friend class boost::serialization::access; 
     84    template<class Archive> 
     85    void serialize(Archive& ar, const unsigned int version) 
     86    { 
     87        ar & BOOST_SERIALIZATION_NVP(transferLimit_); 
     88        ar & BOOST_SERIALIZATION_NVP(connections_); 
     89        ar & BOOST_SERIALIZATION_NVP(uploads_); 
     90        ar & BOOST_SERIALIZATION_NVP(paused_); 
     91        ar & BOOST_SERIALIZATION_NVP(filename_); 
     92        ar & BOOST_SERIALIZATION_NVP(saveDirectory_); 
     93    } 
     94         
     95private:                 
     96        std::pair<float, float> transferLimit_; 
     97         
     98        int connections_; 
     99        int uploads_; 
     100        bool paused_; 
     101        bool inSession_; 
     102         
     103        std::wstring filename_; 
     104        std::string saveDirectory_; 
     105        libtorrent::torrent_handle handle_;      
     106}; 
     107 
     108typedef std::map<std::string, TorrentInternal> TorrentMap; 
    31109 
    32110lbt::entry haldecode(const path &file)  
     
    179257{ 
    180258        friend class BitTorrent; 
     259public: 
     260         
     261        ~BitTorrent_impl() 
     262        { 
     263                try 
     264                { 
     265                        boost::filesystem::ofstream ofs(workingDirectory/"Torrents.xml"); 
     266                        boost::archive::xml_oarchive oa(ofs); 
     267                         
     268                        oa << make_nvp("torrents", torrents); 
     269                        return; 
     270                } 
     271                catch(const std::exception&) 
     272                { 
     273                        return; 
     274                }        
     275        } 
    181276         
    182277private: 
    183278        BitTorrent_impl() : 
    184279                theSession(lbt::fingerprint("HL", 0, 2, 0, 8)), 
    185                 torrents(INI().torrentConfig().torrents), 
    186280                workingDirectory(globalModule().exePath().branch_path()) 
    187         {} 
     281        { 
     282                boost::filesystem::ifstream ifs(workingDirectory/"Torrents.xml"); 
     283                if (ifs) 
     284                { 
     285                        boost::archive::xml_iarchive ia(ifs); 
     286                         
     287                        ia >> make_nvp("torrents", torrents); 
     288                }                
     289        } 
    188290         
    189291        lbt::entry prepTorrent(path filename, path saveDirectory); 
     
    191293         
    192294        lbt::session theSession; 
    193         path workingDirectory; 
    194         TorrentMap& torrents; 
     295        TorrentMap torrents; 
     296        const path workingDirectory; 
    195297}; 
    196298 
  • src/halTorrent.hpp

    r107 r110  
    66 
    77#include <boost/date_time/posix_time/posix_time.hpp> 
    8 #include <boost/smart_ptr.hpp> 
    98#include <boost/smart_ptr.hpp> 
    109#include <boost/algorithm/string.hpp> 
     
    2221struct torrentBriefDetail  
    2322{ 
    24         wstring filename; 
    25         wstring status; 
    26         pair<float,float> speed; 
     23        std::wstring filename; 
     24        std::wstring status; 
     25        std::pair<float,float> speed; 
    2726        float completion; 
    2827        int peers; 
     
    8988struct PeerDetail  
    9089{ 
    91         PeerDetail(const wstring& ip_address) : 
     90        PeerDetail(const std::wstring& ip_address) : 
    9291                ipAddress(ip_address) 
    9392        {} 
     
    105104         
    106105        wstring ipAddress; 
    107         pair<float,float> speed; 
     106        std::pair<float,float> speed; 
    108107        bool seed; 
    109         wstring client; 
     108        std::wstring client; 
    110109}; 
    111110 
     
    120119        void shutDownSession(); 
    121120         
    122         bool listenOn(pair<int, int> const& portRange); 
     121        bool listenOn(std::pair<int, int> const& portRange); 
    123122        int isListeningOn(); 
    124123        void stopListening(); 
     
    126125        void setSessionLimits(int maxConn, int maxUpload); 
    127126        void setSessionSpeed(float download, float upload); 
    128         pair<double, double> sessionSpeed(); 
     127        std::pair<double, double> sessionSpeed(); 
    129128         
    130129        void newTorrent(boost::filesystem::path filename, boost::filesystem::path files); 
    131130        void addTorrent(boost::filesystem::path file, path saveDirectory); 
    132131        void getAllTorrentDetails(TorrentDetails& torrentsContainer); 
    133         TorrentDetail_ptr getTorrentDetails(string filename); 
     132        TorrentDetail_ptr getTorrentDetails(std::string filename); 
    134133         
    135         void getAllPeerDetails(string filename, PeerDetails& peerContainer); 
     134        void getAllPeerDetails(std::string filename, PeerDetails& peerContainer); 
    136135         
    137136        void resumeAll(); 
    138137        void closeAll(); 
    139138         
    140         bool isTorrent(string filename); 
     139        bool isTorrent(std::string filename); 
    141140         
    142         void pauseTorrent(string filename); 
    143         void resumeTorrent(string filename); 
    144         bool isTorrentPaused(string filename); 
     141        void pauseTorrent(std::string filename); 
     142        void resumeTorrent(std::string filename); 
     143        bool isTorrentPaused(std::string filename); 
    145144         
    146145        void pauseAllTorrents(); 
    147146        void resumeAllTorrents(); 
    148147         
    149         void removeTorrent(string filename); 
    150         void reannounceTorrent(string filename); 
     148        void removeTorrent(std::string filename); 
     149        void reannounceTorrent(std::string filename); 
    151150         
    152         void setTorrentLimit(string filename, int maxConn, int maxUpload); 
    153         void setTorrentSpeed(string filename, float download, float upload); 
    154         pair<int, int> getTorrentLimit(string filename); 
    155         pair<float, float> getTorrentSpeed(string filename); 
     151        void setTorrentLimit(std::string filename, int maxConn, int maxUpload); 
     152        void setTorrentSpeed(std::string filename, float download, float upload); 
     153        pair<int, int> getTorrentLimit(std::string filename); 
     154        pair<float, float> getTorrentSpeed(std::string filename); 
    156155         
    157156        friend BitTorrent& bittorrent(); 
  • src/ini/Torrent.hpp

    r107 r110  
    8585         
    8686        std::wstring filename_; 
    87         string saveDirectory_; 
     87        std::string saveDirectory_; 
    8888        libtorrent::torrent_handle handle_;      
    8989}; 
  • src/stdAfx.hpp

    r107 r110  
    4242#include <boost/filesystem/path.hpp> 
    4343#include <boost/filesystem/operations.hpp> 
     44#include <boost/noncopyable.hpp> 
    4445 
    4546using std::string; 
     
    5657using boost::scoped_ptr; 
    5758using boost::filesystem::path; 
     59using boost::noncopyable; 
    5860 
    5961wstring mbstowcs(const string &str); 
Note: See TracChangeset for help on using the changeset viewer.