Changeset 229


Ignore:
Timestamp:
07/04/07 19:07:52 (13 years ago)
Author:
Eoin
Message:

Big changes to UI updating along with a changed meaning for 'stopped' as related to torrents. Now they act like 'Not in Session'.

Location:
src
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • src/AdvHaliteDialog.hpp

    r181 r229  
    1818class CHaliteListViewCtrl; 
    1919 
    20 typedef selection_manager<CHaliteListViewCtrl<HaliteListViewCtrl> > ListViewManager; 
     20typedef CHaliteListViewCtrl<HaliteListViewCtrl>::selection_manage_class ListViewManager; 
    2121 
    2222class HaliteWindow; 
     
    3333        enum { IDD = IDD_ADVHALITEDLG }; 
    3434 
    35         AdvHaliteDialog(ui_signal& ui_sig, ListViewManager& single_sel) : 
    36                 m_torrent(ui_sig, single_sel), 
    37                 m_peers(ui_sig, single_sel), 
    38                 m_tracker(ui_sig, single_sel), 
    39                 m_debug(ui_sig, single_sel) 
     35        AdvHaliteDialog(HaliteWindow& halWindow, ui_signal& ui_sig, ListViewManager& single_sel) : 
     36                m_torrent(halWindow, ui_sig, single_sel), 
     37                m_peers(halWindow, ui_sig, single_sel), 
     38                m_tracker(halWindow, ui_sig, single_sel), 
     39                m_debug(halWindow, ui_sig, single_sel) 
    4040        {} 
    4141 
  • src/HaliteDialog.cpp

    r202 r229  
    1010#include "halEvent.hpp" 
    1111 
    12 HaliteDialog::HaliteDialog(ui_signal& ui_sig, ListViewManager& single_sel) : 
    13 //      iniClass("dialogs/halite", "HaliteDialog"), 
    14         dialogBaseClass(ui_sig, single_sel) 
     12HaliteDialog::HaliteDialog(HaliteWindow& halWindow, ui_signal& ui_sig, ListViewManager& single_sel) : 
     13                dialogBaseClass(halWindow, ui_sig, single_sel) 
    1514{ 
    1615//      ui_.attach(bind(&HaliteDialog::updateDialog, this)); 
     
    2524        pair<int, int> connLimit(-1, -1); 
    2625         
     26#       if 0     
    2727        if (hal::bittorrent().isTorrent(torrent_name)) 
    2828        { 
     
    7171         
    7272        DoDataExchange(false);   
    73          
     73#       endif 
    7474        m_list.DeleteAllItems();         
    7575        ui().update(); 
     
    160160} 
    161161 
     162void HaliteDialog::uiUpdate(const hal::TorrentDetails& torrentDetails) 
     163{ 
     164        hal::TorrentDetails::const_iterator ppTd = torrentDetails.begin(); 
     165        hal::TorrentDetail_ptr pTd; 
     166         
     167        if ((ppTd != torrentDetails.end()) && (pTd = *ppTd))     
     168        { 
     169                SetDlgItemText(IDC_NAME, pTd->filename().c_str()); 
     170                SetDlgItemText(IDC_TRACKER, pTd->currentTracker().c_str()); 
     171                SetDlgItemText(IDC_STATUS, pTd->state().c_str()); 
     172                m_prog.SetPos(static_cast<int>(pTd->completion()*100)); 
     173                 
     174                if (!pTd->estimatedTimeLeft().is_special()) 
     175                { 
     176                        SetDlgItemText(IDC_AVAIL, 
     177                                (hal::from_utf8(boost::posix_time::to_simple_string(pTd->estimatedTimeLeft())).c_str())); 
     178                } 
     179                else 
     180                { 
     181                        SetDlgItemText(IDC_AVAIL,L"∞");          
     182                } 
     183                 
     184                SetDlgItemText(IDC_COMPLETE, 
     185                        (wformat(L"%1$.2fmb of %2$.2fmb")  
     186                                % (static_cast<float>(pTd->totalWantedDone())/(1024*1024)) 
     187                                % (static_cast<float>(pTd->totalWanted())/(1024*1024)) 
     188                        ).str().c_str()); 
     189                                 
     190                m_list.SetRedraw(false); 
     191                m_list.manager().clearAll(); 
     192                 
     193                if (!pTd->peerDetails().empty()) 
     194                {                        
     195                         
     196                        foreach (const hal::PeerDetail& peer, pTd->peerDetails()) 
     197                        {                        
     198                                LV_FINDINFO findInfo;  
     199                                findInfo.flags = LVFI_STRING; 
     200                                findInfo.psz = const_cast<LPTSTR>(peer.ipAddress.c_str()); 
     201                                 
     202                                int itemPos = m_list.FindItem(&findInfo, -1); 
     203                                if (itemPos < 0) 
     204                                        itemPos = m_list.AddItem(0, 0, peer.ipAddress.c_str(), 0); 
     205                                 
     206                                m_list.SetItemText(itemPos, 1, 
     207                                        (wformat(L"%1$.2fKB/s")  
     208                                                % (peer.speed.first/1024) 
     209                                        ).str().c_str());        
     210                                 
     211                                m_list.SetItemText(itemPos, 2, 
     212                                        (wformat(L"%1$.2fKB/s")  
     213                                                % (peer.speed.second/1024) 
     214                                        ).str().c_str());        
     215                                 
     216                                if (peer.seed) 
     217                                        m_list.SetItemText(itemPos, 3, L"Seed"); 
     218                                 
     219                                m_list.SetItemText(itemPos, 4, peer.client.c_str()); 
     220                        }                        
     221                } 
     222                 
     223                m_list.SetRedraw(true); 
     224        } 
     225        else 
     226        { 
     227                 
     228/*              SetDlgItemText(IDC_NAME, L"N/A"); 
     229                SetDlgItemText(IDC_TRACKER, L"N/A"); 
     230                SetDlgItemText(IDC_STATUS, L"N/A"); 
     231                SetDlgItemText(IDC_AVAIL, L"N/A"); 
     232                SetDlgItemText(IDC_COMPLETE, L"N/A"); 
     233                 
     234                SetDlgItemText(BTNPAUSE, L"Pause"); 
     235                 
     236                ::EnableWindow(GetDlgItem(BTNPAUSE), false); 
     237                ::EnableWindow(GetDlgItem(BTNREANNOUNCE), false); 
     238                ::EnableWindow(GetDlgItem(BTNREMOVE), false); 
     239                 
     240                ::EnableWindow(GetDlgItem(IDC_EDITTLD), false); 
     241                ::EnableWindow(GetDlgItem(IDC_EDITTLU), false); 
     242                ::EnableWindow(GetDlgItem(IDC_EDITNCD), false); 
     243                ::EnableWindow(GetDlgItem(IDC_EDITNCU), false); 
     244                 
     245                m_list.DeleteAllItems(); 
     246*/ 
     247        } 
     248} 
     249 
    162250void HaliteDialog::updateDialog() 
    163251{ 
     252#       if 0 
     253 
    164254        hal::TorrentDetail_ptr pTD = hal::bittorrent().getTorrentDetails( 
    165255                selection_manager().selected()); 
     
    265355*/ 
    266356        } 
    267 } 
     357#       endif 
     358} 
  • src/HaliteDialog.hpp

    r202 r229  
    1414 
    1515class HaliteListViewCtrl; 
    16 typedef selection_manager<CHaliteListViewCtrl<HaliteListViewCtrl> > ListViewManager; 
     16typedef CHaliteListViewCtrl<HaliteListViewCtrl>::selection_manage_class ListViewManager; 
    1717 
    1818class HaliteDialog : 
     
    3030//      typedef CHaliteIni<HaliteDialog> iniClass; 
    3131        typedef CHaliteDialogBase<HaliteDialog> dialogBaseClass; 
    32          
    33          
     32                 
    3433        class DialogListView : 
    3534                public CHaliteListViewCtrl<DialogListView>, 
     
    8180                        saveSettings(); 
    8281                } 
    83                  
     82                                 
    8483                friend class boost::serialization::access; 
    8584                template<class Archive> 
     
    9493        enum { IDD = IDD_HALITEDLG }; 
    9594 
    96         HaliteDialog(ui_signal& ui_sig, ListViewManager& single_sel); 
     95        HaliteDialog(HaliteWindow& HalWindow, ui_signal& ui_sig, ListViewManager& single_sel); 
    9796        BOOL PreTranslateMessage(MSG* pMsg)     { return this->IsDialogMessage(pMsg); } 
    9897 
     
    153152        void selectionChanged(const string& torrent_name); 
    154153        void updateDialog(); 
     154        void uiUpdate(const hal::TorrentDetails& torrentDetails); 
    155155         
    156156protected: 
  • src/HaliteDialogBase.hpp

    r201 r229  
    1010#include <boost/archive/xml_wiarchive.hpp> 
    1111 
    12 template <class T> 
     12template <class TBase> 
    1313class CHaliteDialogBase 
    1414{ 
     15        typedef CHaliteDialogBase<TBase> thisClass; 
     16         
    1517public: 
    16         CHaliteDialogBase(ui_signal& ui_sig, ListViewManager& single_sel) : 
     18        CHaliteDialogBase(HaliteWindow& theDaddy, ui_signal& ui_sig, ListViewManager& single_sel) : 
    1719                ui_(ui_sig), 
    1820                selection_manager_(single_sel) 
    19         {} 
     21        {                
     22                theDaddy.connectUiUpdate(bind(&TBase::uiUpdate, static_cast<TBase*>(this), _1)); 
     23        } 
    2024         
    2125        void InitializeHalDialogBase() 
    2226        {        
    23                 ui_.attach(bind(&T::updateDialog, static_cast<T*>(this))); 
    24                 selection_manager_.attach(bind(&T::selectionChanged, static_cast<T*>(this), _1)); 
     27                ui_.attach(bind(&TBase::updateDialog, static_cast<TBase*>(this))); 
     28                selection_manager_.attach(bind(&TBase::selectionChanged, static_cast<TBase*>(this), _1)); 
    2529        } 
     30         
     31        void uiUpdate(const hal::TorrentDetails& torrentDetails) {} 
    2632         
    2733/*      void save() 
  • src/HaliteListManager.hpp

    r153 r229  
    55#include <boost/signal.hpp> 
    66 
    7 template <typename L, typename S=std::string> 
    8 class selection_manager :  
    9         private boost::noncopyable 
    10 { 
    11 public: 
    12         selection_manager(L& m_list) : 
    13                 m_list_(m_list) 
    14         {} 
    15         typedef const S& param_type; 
    16          
    17         void sync_list(bool list_to_manager) 
    18         { 
    19                 if (list_to_manager) 
    20                 {        
    21                         all_selected_.clear(); 
    22                         int itemPos = m_list_.GetSelectionMark();        
    23                  
    24                         if (itemPos != -1) 
    25                         { 
    26                                 boost::array<wchar_t, MAX_PATH> pathBuffer; 
    27                                 m_list_.GetItemText(itemPos, 0, pathBuffer.c_array(), pathBuffer.size());        
    28                                  
    29                                 // Multi-Selected 
    30                                 int total = m_list_.GetItemCount(); 
    31                                  
    32                                 for (int i=0; i<total; ++i) 
    33                                 { 
    34                                         UINT flags = m_list_.GetItemState(i, LVIS_SELECTED); 
    35                                          
    36                                         if (flags && LVIS_SELECTED) 
    37                                         { 
    38                                                 m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size());      
    39                                                 all_selected_.push_back(hal::to_utf8(pathBuffer.data())); 
    40                                         } 
    41                                 } 
    42                                  
    43                                 // Single-Selected 
    44                                 string selected = hal::to_utf8(pathBuffer.data()); 
    45                                  
    46                                 if (selected_ != selected) 
    47                                 { 
    48                                         selected_ = selected; 
    49                                         signal(); 
    50                                 } 
    51                         } 
    52                         else 
    53                         { 
    54                                 selected_ = ""; 
    55                                 signal(); 
    56                         } 
    57                 } 
    58                 else 
    59                 { 
    60                         LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };  
    61                         findInfo.flags = LVFI_STRING; 
    62                          
    63                         wstring torrent_name = hal::from_utf8(selected_);                
    64                         findInfo.psz = torrent_name.c_str(); 
    65                          
    66                         int itemPos = m_list_.FindItem(&findInfo, -1);   
    67                          
    68                         if (itemPos != m_list_.GetSelectionMark()) 
    69                         { 
    70                                 LVITEM lvi = { LVIF_STATE }; 
    71                                 lvi.state = LVIS_SELECTED; 
    72                                 lvi.stateMask = LVIS_SELECTED; 
    73                                 m_list_.SetItemState(itemPos, &lvi); 
    74                                 m_list_.SetSelectionMark(itemPos); 
    75                                 signal(); 
    76                         } 
    77                 } 
    78         } 
    79          
    80         param_type selected() const { return selected_; } 
    81          
    82         int selectedIndex() 
    83         { 
    84                 wstring torrent_name = hal::from_utf8(selected_);        
    85                 LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };          
    86                 findInfo.psz = torrent_name.c_str(); 
    87                  
    88                 return m_list_.FindItem(&findInfo, -1);          
    89         } 
    90          
    91         const std::vector<string>& allSelected() const { return all_selected_; } 
    92          
    93         void setSelected(const string& sel)  
    94         { 
    95                 selected_ = sel; 
    96                 sync_list(false); 
    97         } 
    98          
    99         void setSelected(int itemPos) 
    100         { 
    101                 LVITEM lvi = { LVIF_STATE }; 
    102                 lvi.state = LVIS_SELECTED; 
    103                 lvi.stateMask = LVIS_SELECTED; 
    104                 m_list_.SetItemState(itemPos, &lvi); 
    105                 m_list_.SetSelectionMark(itemPos); 
    106                 sync_list(true); 
    107         } 
    108          
    109         void clear() 
    110         { 
    111                 m_list_.DeleteItem(m_list_.GetSelectionMark()); 
    112                  
    113         //      m_list_.SelectItem(0); 
    114                 sync_list(true);         
    115         } 
    116          
    117         void clearAllSelected() 
    118         { 
    119                 int total = m_list_.GetItemCount(); 
    120                  
    121                 for (int i=total-1; i>=0; --i) 
    122                 { 
    123                         UINT flags = m_list_.GetItemState(i, LVIS_SELECTED); 
    124                          
    125                         if (flags && LVIS_SELECTED) 
    126                                 m_list_.DeleteItem(i); 
    127                 } 
    128                 all_selected_.clear(); 
    129                  
    130         //      m_list_.SelectItem(0); 
    131                 sync_list(true);         
    132         } 
    133          
    134         void clearAll() 
    135         { 
    136                 m_list_.DeleteAllItems(); 
    137                 all_selected_.clear(); 
    138                 sync_list(true);                 
    139         } 
    140          
    141         void attach(boost::function<void (param_type)> fn) { selection_.connect(fn); } 
    142         void signal() { selection_(selected_); } 
    143          
    144 private: 
    145         S selected_; 
    146         std::vector<S> all_selected_; 
    147          
    148         boost::signal<void (param_type)> selection_; 
    149         L& m_list_; 
    150 }; 
     7 
  • src/HaliteListView.cpp

    r151 r229  
    2525{ 
    2626        hal::TorrentDetails TD; 
    27         hal::bittorrent().getAllTorrentDetails(TD); 
     27        hal::bittorrent().getAllTorrentDetails(TD, ""); 
    2828         
    2929        for (hal::TorrentDetails::const_iterator i = TD.begin(); i != TD.end(); ++i)  
  • src/HaliteListView.hpp

    r151 r229  
    6969                ar & boost::serialization::make_nvp("listview", boost::serialization::base_object<listClass>(*this)); 
    7070    } 
     71                                 
     72        void connectForDetails(boost::function<void (const hal::TorrentDetails&)> fn)  
     73        {  
     74                selection_details_.connect(fn);  
     75        } 
    7176 
    7277private: 
    7378        void OnAttach(); 
    7479        void OnDetach(); 
     80         
     81        boost::signal<void (const hal::TorrentDetails&)> selection_details_; 
     82         
     83        hal::TorrentDetails torrentDetails_; 
    7584}; 
    7685 
    77 typedef selection_manager<CHaliteListViewCtrl<HaliteListViewCtrl> > ListViewManager; 
     86typedef HaliteListViewCtrl::selection_manage_class ListViewManager; 
  • src/HaliteListViewCtrl.hpp

    r221 r229  
    99 
    1010#include "stdAfx.hpp" 
    11 #include "HaliteListManager.hpp" 
     11#include "halTorrent.hpp" 
    1212 
    1313template <class TBase> 
    1414class CHaliteListViewCtrl : public CWindowImpl<TBase, CListViewCtrl> 
    1515{ 
    16  
     16public: 
     17        typedef CHaliteListViewCtrl<TBase> thisClass; 
     18         
     19protected: 
     20 
     21        template <typename L, typename S=std::string> 
     22        class selection_manager :  
     23                private boost::noncopyable 
     24        { 
     25         
     26        public: 
     27                selection_manager(L& m_list) : 
     28                        m_list_(m_list) 
     29                {} 
     30                 
     31                typedef const S& param_type; 
     32                 
     33                void sync_list(bool list_to_manager) 
     34                { 
     35                        if (list_to_manager) 
     36                        {        
     37                                all_selected_.clear(); 
     38                                int itemPos = m_list_.GetSelectionMark();        
     39                         
     40                                if (itemPos != -1) 
     41                                { 
     42                                        boost::array<wchar_t, MAX_PATH> pathBuffer; 
     43                                        m_list_.GetItemText(itemPos, 0, pathBuffer.c_array(), pathBuffer.size());        
     44                                         
     45                                        // Multi-Selected 
     46                                        int total = m_list_.GetItemCount(); 
     47                                         
     48                                        for (int i=0; i<total; ++i) 
     49                                        { 
     50                                                UINT flags = m_list_.GetItemState(i, LVIS_SELECTED); 
     51                                                 
     52                                                if (flags && LVIS_SELECTED) 
     53                                                { 
     54                                                        m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size());      
     55                                                        all_selected_.push_back(hal::to_utf8(pathBuffer.data())); 
     56                                                } 
     57                                        } 
     58                                         
     59                                        // Single-Selected 
     60                                        string selected = hal::to_utf8(pathBuffer.data()); 
     61                                         
     62                                        if (selected_ != selected) 
     63                                        { 
     64                                                selected_ = selected; 
     65                                                signal(); 
     66                                        } 
     67                                } 
     68                                else 
     69                                { 
     70                                        selected_ = ""; 
     71                                        signal(); 
     72                                } 
     73                        } 
     74                        else 
     75                        { 
     76                                LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };  
     77                                findInfo.flags = LVFI_STRING; 
     78                                 
     79                                wstring torrent_name = hal::from_utf8(selected_);                
     80                                findInfo.psz = torrent_name.c_str(); 
     81                                 
     82                                int itemPos = m_list_.FindItem(&findInfo, -1);   
     83                                 
     84                                if (itemPos != m_list_.GetSelectionMark()) 
     85                                { 
     86                                        LVITEM lvi = { LVIF_STATE }; 
     87                                        lvi.state = LVIS_SELECTED; 
     88                                        lvi.stateMask = LVIS_SELECTED; 
     89                                        m_list_.SetItemState(itemPos, &lvi); 
     90                                        m_list_.SetSelectionMark(itemPos); 
     91                                        signal(); 
     92                                } 
     93                        } 
     94                } 
     95                 
     96                param_type selected() const { return selected_; } 
     97                 
     98                int selectedIndex() 
     99                { 
     100                        wstring torrent_name = hal::from_utf8(selected_);        
     101                        LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };          
     102                        findInfo.psz = torrent_name.c_str(); 
     103                         
     104                        return m_list_.FindItem(&findInfo, -1);          
     105                } 
     106                 
     107                const std::vector<string>& allSelected() const { return all_selected_; } 
     108                 
     109                void setSelected(const string& sel)  
     110                { 
     111                        selected_ = sel; 
     112                        sync_list(false); 
     113                } 
     114                 
     115                void setSelected(int itemPos) 
     116                { 
     117                        LVITEM lvi = { LVIF_STATE }; 
     118                        lvi.state = LVIS_SELECTED; 
     119                        lvi.stateMask = LVIS_SELECTED; 
     120                        m_list_.SetItemState(itemPos, &lvi); 
     121                        m_list_.SetSelectionMark(itemPos); 
     122                        sync_list(true); 
     123                } 
     124                 
     125                void clear() 
     126                { 
     127                        m_list_.DeleteItem(m_list_.GetSelectionMark()); 
     128                         
     129                //      m_list_.SelectItem(0); 
     130                        sync_list(true);         
     131                } 
     132                 
     133                void clearAllSelected() 
     134                { 
     135                        int total = m_list_.GetItemCount(); 
     136                         
     137                        for (int i=total-1; i>=0; --i) 
     138                        { 
     139                                UINT flags = m_list_.GetItemState(i, LVIS_SELECTED); 
     140                                 
     141                                if (flags && LVIS_SELECTED) 
     142                                        m_list_.DeleteItem(i); 
     143                        } 
     144                        all_selected_.clear(); 
     145                         
     146                //      m_list_.SelectItem(0); 
     147                        sync_list(true);         
     148                } 
     149                 
     150                void clearAll() 
     151                { 
     152                        m_list_.DeleteAllItems(); 
     153                        all_selected_.clear(); 
     154                        sync_list(true);                 
     155                } 
     156                 
     157                void attach(boost::function<void (param_type)> fn) { selection_.connect(fn); } 
     158                 
     159                void signal()  
     160                {  
     161                        selection_(selected_);  
     162                } 
     163                 
     164        private: 
     165                S selected_; 
     166                std::vector<S> all_selected_; 
     167                 
     168                boost::signal<void (param_type)> selection_; 
     169                L& m_list_; 
     170        }; 
     171         
    17172        class CHaliteHeaderCtrl : public CWindowImpl<CHaliteHeaderCtrl, CHeaderCtrl> 
    18173        { 
     
    36191                         
    37192                        menu_.InsertMenuItem(0, false, &minfo); 
    38         //      TBase* pT = static_cast<TBase*>(this); 
     193//                      TBase* pT = static_cast<TBase*>(this); 
    39194//                      pT->OnAttach(); 
    40195                } 
     
    65220 
    66221public: 
     222 
     223        typedef selection_manager<thisClass> selection_manage_class; 
     224         
    67225        CHaliteListViewCtrl<TBase>() : 
    68226                manager_(*this) 
  • src/HaliteWindow.cpp

    r209 r229  
    8282                LVS_REPORT|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|LVS_SHOWSELALWAYS); 
    8383         
    84         mp_dlg.reset(new HaliteDialog(ui(), mp_list->manager())), 
     84        mp_dlg.reset(new HaliteDialog(*this, ui(), mp_list->manager())), 
    8585        mp_dlg->Create(m_Split.m_hWnd); 
    8686//      mp_dlg->ShowWindow(true); 
    8787         
    88         mp_advDlg.reset(new AdvHaliteDialog(ui(), mp_list->manager())); 
     88        mp_advDlg.reset(new AdvHaliteDialog(*this, ui(), mp_list->manager())); 
    8989        mp_advDlg->Create(m_Split.m_hWnd); 
    9090//      mp_advDlg->ShowWindow(true); 
     
    215215                try 
    216216                { 
     217                 
     218                hal::TorrentDetails td; 
     219                hal::bittorrent().getAllTorrentDetails(td, mp_list->manager().selected()); 
     220                ui_update_signal_(td); 
    217221                 
    218222                ui().update(); 
  • src/HaliteWindow.hpp

    r209 r229  
    66#include "NTray.hpp" 
    77#include "HaliteIni.hpp" 
     8#include "halTorrent.hpp" 
    89 
    910#include <boost/archive/xml_oarchive.hpp> 
     
    9697 
    9798        void ProcessFile(LPCTSTR lpszPath); 
    98  
     99         
     100        void connectUiUpdate(boost::function<void (const hal::TorrentDetails& torrentDetails)> fn)  
     101        {  
     102                ui_update_signal_.connect(fn);  
     103        } 
     104                 
     105        boost::signal<void (const hal::TorrentDetails& torrentDetails)> & ui_sig() { return ui_update_signal_; } 
     106         
     107        void connectSaveState(boost::function<void ()> fn)  
     108        {  
     109                save_state_signal_.connect(fn);  
     110        } 
     111         
    99112protected: 
    100113        typedef CHaliteIni<HaliteWindow> iniClass; 
     
    153166                ar & BOOST_SERIALIZATION_NVP(activeTab); 
    154167        } 
    155  
     168         
    156169        friend class GeneralOptions; 
    157170 
     
    177190        bool advancedUI; 
    178191        int activeTab; 
     192         
     193        boost::signal<void (const hal::TorrentDetails& torrentDetails)> ui_update_signal_; 
     194        boost::signal<void ()> save_state_signal_;       
    179195}; 
    180196 
  • src/advtabs/Debug.cpp

    r201 r229  
    88void AdvDebugDialog::selectionChanged(const string& torrent_name) 
    99{        
     10#       if 0 
    1011        if (hal::bittorrent().isTorrent(torrent_name)) 
    1112        {                
     
    2021         
    2122        onLoginCheck(0, 0, GetDlgItem(IDC_TRACKER_LOGINCHECK)); 
    22          
     23 
     24#       endif    
    2325        DoDataExchange(false);   
    2426        ui().update(); 
  • src/advtabs/Debug.hpp

    r201 r229  
    167167        enum { IDD = IDD_ADVDEBUGLOG }; 
    168168 
    169         AdvDebugDialog(ui_signal& ui_sig, ListViewManager& single_sel) : 
    170                 dialogBaseClass(ui_sig, single_sel) 
     169        AdvDebugDialog(HaliteWindow& halWindow, ui_signal& ui_sig, ListViewManager& single_sel) : 
     170                dialogBaseClass(halWindow, ui_sig, single_sel) 
    171171        {} 
    172172         
  • src/advtabs/Peers.cpp

    r201 r229  
    1515void AdvPeerDialog::updateDialog() 
    1616{ 
     17#       if 0 
    1718        hal::PeerDetails peerDetails; 
    1819        hal::bittorrent().getAllPeerDetails(selection_manager().selected(), peerDetails); 
     
    7475                m_list.DeleteAllItems(); 
    7576        } 
     77#       endif 
    7678} 
    7779 
  • src/advtabs/Peers.hpp

    r201 r229  
    8888        enum { IDD = IDD_ADVPEER }; 
    8989 
    90         AdvPeerDialog(ui_signal& ui_sig, ListViewManager& single_sel) : 
    91                 dialogBaseClass(ui_sig, single_sel) 
     90        AdvPeerDialog(HaliteWindow& halWindow, ui_signal& ui_sig, ListViewManager& single_sel) : 
     91                dialogBaseClass(halWindow, ui_sig, single_sel) 
    9292        {} 
    9393 
  • src/advtabs/Torrent.cpp

    r201 r229  
    1515        pair<int, int> connLimit(-1, -1); 
    1616        float ratio = 0; 
    17          
     17 
     18#       if 0     
    1819        if (hal::bittorrent().isTorrent(torrent_name)) 
    1920        { 
     
    6667        TranLimitUp = tranLimit.second; 
    6768        Ratio = ratio; 
    68          
     69#       endif    
     70 
    6971        DoDataExchange(false);   
    7072        ui().update(); 
     
    110112void AdvTorrentDialog::updateDialog() 
    111113{ 
     114#       if 0 
    112115        hal::TorrentDetail_ptr pTD = hal::bittorrent().getTorrentDetails( 
    113116                selection_manager().selected()); 
     
    152155                else SetDlgItemText(IDC_UPDATE, L"N/A");                 
    153156        } 
     157#       endif 
    154158} 
  • src/advtabs/Torrent.hpp

    r201 r229  
    2727        enum { IDD = IDD_ADVOVERVIEW }; 
    2828 
    29         AdvTorrentDialog(ui_signal& ui_sig, ListViewManager& single_sel) : 
    30                 dialogBaseClass(ui_sig, single_sel) 
     29        AdvTorrentDialog(HaliteWindow& HalWindow, ui_signal& ui_sig, ListViewManager& single_sel) : 
     30                dialogBaseClass(HalWindow, ui_sig, single_sel) 
    3131        {} 
    3232 
     
    9494        void selectionChanged(const string& torrent_name); 
    9595        void updateDialog(); 
     96        void uiUpdate(const hal::TorrentDetails& torrentDetails) {} 
    9697 
    9798protected: 
  • src/advtabs/Tracker.cpp

    r201 r229  
    1010void AdvTrackerDialog::selectionChanged(const string& torrent_name) 
    1111{        
     12 
     13#       if 0 
    1214        if (hal::bittorrent().isTorrent(torrent_name)) 
    1315        {                
     
    4345         
    4446        setLoginUiState(torrent_name); 
    45          
     47#       endif    
     48 
    4649        DoDataExchange(false);   
    47  
    4850        ui().update(); 
    4951} 
  • src/advtabs/Tracker.hpp

    r201 r229  
    3232        enum { IDD = IDD_ADVTRACKER }; 
    3333 
    34         AdvTrackerDialog(ui_signal& ui_sig, ListViewManager& single_sel) : 
    35                 dialogBaseClass(ui_sig, single_sel) 
     34        AdvTrackerDialog(HaliteWindow& HalWindow, ui_signal& ui_sig, ListViewManager& single_sel) : 
     35                dialogBaseClass(HalWindow, ui_sig, single_sel) 
    3636        {} 
    3737 
  • src/advtabs/TrackerListView.hpp

    r152 r229  
    7979}; 
    8080 
    81 typedef selection_manager<TrackerListViewCtrl> TrackerListViewManager; 
     81typedef TrackerListViewCtrl::selection_manage_class TrackerListViewManager; 
  • src/halEvent.hpp

    r154 r229  
    135135        virtual std::wstring msg() 
    136136        { 
    137                 return (wformat(hal::app().res_wstr(code())) % torrent_).str(); 
     137                return (wformat(hal::app().res_wstr(code())) % torrent_ % function_).str(); 
    138138        } 
    139139         
  • src/halTorrent.cpp

    r228 r229  
    874874} 
    875875 
    876 void BitTorrent::getAllTorrentDetails(TorrentDetails& torrentsContainer) 
    877 { 
    878         try { 
    879          
    880         for (TorrentMap::const_iterator iter = pimpl->torrents.begin();  
    881                 iter != pimpl->torrents.end(); ++iter) 
    882         { 
    883                 torrentsContainer.push_back(iter->second.getTorrentDetails()); 
     876void BitTorrent::getAllTorrentDetails(TorrentDetails& torrentsContainer, std::string filename) 
     877{ 
     878        try { 
     879         
     880        foreach (TorrentPair t, pimpl->torrents) 
     881        { 
     882                if (t.first == filename)                 
     883                        torrentsContainer.insert(torrentsContainer.begin(), t.second.getTorrentDetails(true));           
     884                else 
     885                        torrentsContainer.push_back(t.second.getTorrentDetails(false)); 
    884886        } 
    885887         
     
    895897        if (i != pimpl->torrents.end()) 
    896898        { 
    897                 return i->second.getTorrentDetails(); 
     899                return i->second.getTorrentDetails(true); 
    898900        } 
    899901         
  • src/halTorrent.hpp

    r228 r229  
    3535        int seeds; 
    3636}; 
     37 
     38struct PeerDetail  
     39{ 
     40        PeerDetail(const std::wstring& ip_address) : 
     41                ipAddress(ip_address) 
     42        {} 
     43        PeerDetail(libtorrent::peer_info& peerInfo); 
     44         
     45        bool operator==(const PeerDetail& peer) const 
     46        { 
     47                return (ipAddress == peer.ipAddress); 
     48        } 
     49         
     50        bool operator<(const PeerDetail& peer) const 
     51        { 
     52                return (ipAddress < peer.ipAddress); 
     53        } 
     54         
     55        wstring ipAddress; 
     56        std::pair<float,float> speed; 
     57        bool seed; 
     58        std::wstring client; 
     59        std::wstring status; 
     60}; 
     61 
     62typedef shared_ptr<PeerDetail> PeerDetail_ptr; 
     63typedef std::vector<PeerDetail> PeerDetails; 
    3764 
    3865class TorrentDetail  
     
    86113        const time_duration& estimatedTimeLeft() { return estimatedTimeLeft_; } 
    87114        const time_duration& updateTrackerIn() { return updateTrackerIn_; } 
    88  
     115         
     116        const PeerDetails peerDetails() { return peerDetails_; } 
     117         
    89118public: 
    90119        std::wstring filename_; 
     
    107136        time_duration estimatedTimeLeft_; 
    108137        time_duration updateTrackerIn_; 
     138         
     139        PeerDetails peerDetails_; 
    109140}; 
    110141 
    111142typedef shared_ptr<TorrentDetail> TorrentDetail_ptr; 
    112143typedef std::vector<TorrentDetail_ptr> TorrentDetails; 
    113  
    114 struct PeerDetail  
    115 { 
    116         PeerDetail(const std::wstring& ip_address) : 
    117                 ipAddress(ip_address) 
    118         {} 
    119         PeerDetail(libtorrent::peer_info& peerInfo); 
    120          
    121         bool operator==(const PeerDetail& peer) const 
    122         { 
    123                 return (ipAddress == peer.ipAddress); 
    124         } 
    125          
    126         bool operator<(const PeerDetail& peer) const 
    127         { 
    128                 return (ipAddress < peer.ipAddress); 
    129         } 
    130          
    131         wstring ipAddress; 
    132         std::pair<float,float> speed; 
    133         bool seed; 
    134         std::wstring client; 
    135         std::wstring status; 
    136 }; 
    137  
    138 typedef shared_ptr<PeerDetail> PeerDetail_ptr; 
    139 typedef std::vector<PeerDetail> PeerDetails; 
    140144 
    141145struct TrackerDetail 
     
    200204        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files); 
    201205        void addTorrent(boost::filesystem::wpath file, wpath saveDirectory); 
    202         void getAllTorrentDetails(TorrentDetails& torrentsContainer); 
     206        void getAllTorrentDetails(TorrentDetails& torrentsContainer, std::string filename); 
    203207        TorrentDetail_ptr getTorrentDetails(std::string filename); 
    204208         
  • src/halTorrentInternal.hpp

    r228 r229  
    5252        {} 
    5353         
    54         TorrentDetail_ptr getTorrentDetails() const; 
     54        TorrentDetail_ptr getTorrentDetails(bool with_peers) const; 
    5555        void setTransferSpeed(float down, float up); 
    5656        void setConnectionLimit(int maxConn, int maxUpload); 
     
    253253        } 
    254254         
     255        void getPeerDetails(PeerDetails& peerDetails) const 
     256        { 
     257                if (in_session_) 
     258                { 
     259                        std::vector<lbt::peer_info> peerInfo; 
     260                        handle_.get_peer_info(peerInfo); 
     261                         
     262                        foreach (lbt::peer_info peer, peerInfo)  
     263                        { 
     264                                peerDetails.push_back(peer); 
     265                        }        
     266                } 
     267        } 
     268         
    255269private: 
    256  
    257270        static libtorrent::session* the_session_; 
    258271         
     
    286299typedef std::pair<std::string, TorrentInternal> TorrentPair; 
    287300 
    288  
    289301void TorrentInternal::setConnectionLimit(int maxConn, int maxUpload) 
    290302{ 
     
    330342} 
    331343 
    332 TorrentDetail_ptr TorrentInternal::getTorrentDetails() const 
     344TorrentDetail_ptr TorrentInternal::getTorrentDetails(bool with_peers) const 
    333345{ 
    334346        if (inSession()) 
     
    383395                totalBase_ = tS.total_payload_upload; 
    384396 
    385                 return TorrentDetail_ptr(new TorrentDetail(filename_, state, hal::from_utf8(tS.current_tracker),  
     397                TorrentDetail_ptr td_p(new TorrentDetail(filename_, state, hal::from_utf8(tS.current_tracker),  
    386398                        pair<float, float>(tS.download_payload_rate, tS.upload_payload_rate), 
    387399                        tS.progress, tS.distributed_copies, tS.total_wanted_done, tS.total_wanted, totalUploaded_, 
    388400                        tS.num_peers, tS.num_seeds, ratio_, td, tS.next_announce)); 
     401                 
     402                if (with_peers) getPeerDetails(td_p->peerDetails_); 
     403                 
     404                return td_p; 
    389405        } 
    390406        else 
Note: See TracChangeset for help on using the changeset viewer.