source: trunk/src/HaliteListView.hpp @ 507

Revision 507, 21.9 KB checked in by Eoin, 11 years ago (diff)

Added ListViewIterators?.hpp.

Major find and replace of TorrentDetails? and associated classes to torrent_details.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#pragma once
8
9#define HAL_MAIN_LISTVIEW_BEGIN                 30000
10#define ID_LVM_DOWNLOAD_FOLDER          HAL_MAIN_LISTVIEW_BEGIN + 1
11#define ID_LVM_RECHECK                                  HAL_MAIN_LISTVIEW_BEGIN + 2
12#define ID_LVM_EDIT_FOLDERS                             HAL_MAIN_LISTVIEW_BEGIN + 3
13#define HAL_LISTVIEW_CONFIRMDELETE              HAL_MAIN_LISTVIEW_BEGIN + 4
14
15#ifndef RC_INVOKED
16
17#include "Halite.hpp"
18
19#include <boost/array.hpp>
20#include <boost/signals.hpp>
21#include <boost/serialization/vector.hpp>
22
23#include "global/string_conv.hpp"
24
25#include "halIni.hpp"
26#include "HaliteListViewCtrl.hpp"
27#include "HaliteSortListViewCtrl.hpp"
28
29class HaliteWindow;
30
31class HaliteListViewCtrl :
32        public CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::torrent_details_ptr>,
33        private hal::IniBase<HaliteListViewCtrl>,
34        private boost::noncopyable
35{
36protected:
37        typedef hal::IniBase<HaliteListViewCtrl> iniClass;
38        typedef CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::torrent_details_ptr> listClass;
39        typedef const hal::torrent_details_ptr tD;
40
41        friend class listClass;
42       
43        struct ColumnAdapters
44        {
45       
46        typedef listClass::ColumnAdapter ColAdapter_t;
47       
48        struct Name : public ColAdapter_t
49        {       
50                virtual int compare(tD& l, tD& r) { return hal::compare(l->name(), r->name()); }               
51                virtual std::wstring print(tD& t) { return t->name(); }         
52        };
53       
54/*      struct Filename : public ColAdapter_t
55        {       
56                virtual int compare(tD& l, tD& r) { return hal::compare(l->filename(), r->filename()); }               
57                virtual std::wstring print(tD& t) { return t->filename(); }             
58        };
59*/     
60        struct State : public ColAdapter_t
61        {       
62                virtual int compare(tD& l, tD& r) { return hal::compare(l->state(), r->state()); }             
63                virtual std::wstring print(tD& t) { return t->state(); }               
64        };
65       
66        struct Tracker : public ColAdapter_t
67        {
68                virtual int compare(tD& l, tD& r) { return hal::compare(l->currentTracker(), r->currentTracker()); }           
69                virtual std::wstring print(tD& t) { return t->currentTracker(); }               
70        };
71       
72        struct SpeedDown : public ColAdapter_t
73        {
74                virtual int compare(tD& l, tD& r) { return hal::compare(l->speed().first, r->speed().first); }         
75                virtual std::wstring print(tD& t) 
76                {
77                        return (wformat(L"%1$.2fkb/s") % (t->speed().first/1024)).str(); 
78                }               
79        };
80       
81        struct SpeedUp : public ColAdapter_t
82        {
83                virtual int compare(tD& l, tD& r) { return hal::compare(l->speed().second, r->speed().second); }               
84                virtual std::wstring print(tD& t) 
85                {
86                        return (wformat(L"%1$.2fkb/s") % (t->speed().second/1024)).str(); 
87                }               
88        };
89
90        struct Progress : public ColAdapter_t
91        {
92                virtual int compare(tD& l, tD& r) { return hal::compare(l->completion(), r->completion()); }           
93                virtual std::wstring print(tD& t) 
94                {
95                        return (wformat(L"%1$.2f%%") % (t->completion()*100)).str(); 
96                }               
97        };
98
99        struct Peers : public ColAdapter_t
100        {
101                virtual int compare(tD& l, tD& r) { return hal::compare(l->peers(), r->peers()); }             
102                virtual std::wstring print(tD& t) 
103                {
104                        return (wformat(L"%1% (%2%)") % t->peersConnected() % t->peers()).str(); 
105                }
106        };
107       
108        struct Seeds : public ColAdapter_t
109        {
110                virtual int compare(tD& l, tD& r) { return hal::compare(l->seeds(), r->seeds()); }                             
111                virtual std::wstring print(tD& t) 
112                {
113                        return (wformat(L"%1% (%2%)") % t->seedsConnected() % t->seeds()).str(); 
114                }       
115        };
116       
117        struct ETA : public ColAdapter_t
118        {
119                virtual int compare(tD& l, tD& r) { return hal::compare(l->estimatedTimeLeft(), r->estimatedTimeLeft()); }             
120                virtual std::wstring print(tD& t) 
121                { 
122                        if (!t->estimatedTimeLeft().is_special())
123                        {
124                                return hal::from_utf8(
125                                        boost::posix_time::to_simple_string(t->estimatedTimeLeft()));
126                        }
127                        else
128                        {
129                                return hal::app().res_wstr(HAL_INF);           
130                        }
131                }               
132        };
133       
134        struct UpdateTrackerIn : public ColAdapter_t
135        {
136                virtual int compare(tD& l, tD& r) { return hal::compare(l->updateTrackerIn(), r->updateTrackerIn()); }         
137                virtual std::wstring print(tD& t) 
138                { 
139                        if (!t->updateTrackerIn().is_special())
140                        {
141                                return hal::from_utf8(
142                                        boost::posix_time::to_simple_string(t->updateTrackerIn()));
143                        }
144                        else
145                        {
146                                return hal::app().res_wstr(HAL_INF);           
147                        }
148                }               
149        };
150       
151        struct Ratio : public ColAdapter_t
152        {
153                virtual int compare(tD& l, tD& r)       
154                { 
155                        float left = (l->totalPayloadDownloaded()) 
156                                        ? static_cast<float>(l->totalPayloadUploaded())
157                                                / static_cast<float>(l->totalPayloadDownloaded())
158                                        : 0;
159                       
160                        float right = (r->totalPayloadDownloaded()) 
161                                        ? static_cast<float>(r->totalPayloadUploaded())
162                                                / static_cast<float>(r->totalPayloadDownloaded())
163                                        : 0;
164                       
165                        return hal::compare(left, right); 
166                }               
167                virtual std::wstring print(tD& t)
168                {
169                        float ratio = (t->totalPayloadDownloaded()) 
170                                        ? static_cast<float>(t->totalPayloadUploaded())
171                                                / static_cast<float>(t->totalPayloadDownloaded())
172                                        : 0;
173                       
174                        return (wformat(L"%1$.2f") % ratio).str(); 
175                }               
176        };
177       
178        struct DistributedCopies : public ColAdapter_t
179        {
180                virtual int compare(tD& l, tD& r) { return hal::compare(l->distributedCopies(), r->distributedCopies()); }             
181                virtual std::wstring print(tD& t) 
182                { 
183                        float copies = t->distributedCopies();
184                       
185                        if (copies < 0)
186                                return L"Seeding"; 
187                        else
188                                return (wformat(L"%1$.2f") % copies).str();             
189                }               
190        };
191
192        struct Remaining : public ColAdapter_t
193        {
194                virtual int compare(tD& l, tD& r)
195                {
196                        boost::int64_t left = l->totalWanted()-l->totalWantedDone();
197                        boost::int64_t right = r->totalWanted()-r->totalWantedDone();
198                       
199                        return hal::compare(left, right); 
200                }
201               
202                virtual std::wstring print(tD& t) 
203                {
204                        return (wformat(L"%1$.2fMB") % (static_cast<float>(t->totalWanted()-t->totalWantedDone())/(1024*1024))).str(); 
205                }               
206        };
207
208        struct Completed : public ColAdapter_t
209        {
210                virtual int compare(tD& l, tD& r)
211                {                       
212                        return hal::compare(l->totalWantedDone(), r->totalWantedDone()); 
213                }
214               
215                virtual std::wstring print(tD& t) 
216                {
217                        return (wformat(L"%1$.2fMB") % (static_cast<float>(t->totalWantedDone())/(1024*1024))).str(); 
218                }               
219        };
220
221        struct TotalWanted : public ColAdapter_t
222        {
223                virtual int compare(tD& l, tD& r)
224                {               
225                        return hal::compare(l->totalWanted(), r->totalWanted()); 
226                }
227               
228                virtual std::wstring print(tD& t) 
229                {
230                        return (wformat(L"%1$.2fMB") % (static_cast<float>(t->totalWanted())/(1024*1024))).str(); 
231                }               
232        };
233
234        struct Downloaded : public ColAdapter_t
235        {
236                virtual int compare(tD& l, tD& r)
237                {               
238                        return hal::compare(l->totalPayloadDownloaded(), r->totalPayloadDownloaded()); 
239                }
240               
241                virtual std::wstring print(tD& t) 
242                {
243                        return (wformat(L"%1$.2fMB") % (static_cast<float>(t->totalPayloadDownloaded())/(1024*1024))).str(); 
244                }               
245        };
246
247        struct Uploaded : public ColAdapter_t
248        {
249                virtual int compare(tD& l, tD& r)
250                {               
251                        return hal::compare(l->totalPayloadUploaded(), r->totalPayloadUploaded()); 
252                }
253               
254                virtual std::wstring print(tD& t) 
255                {
256                        return (wformat(L"%1$.2fMB") % (static_cast<float>(t->totalPayloadUploaded())/(1024*1024))).str(); 
257                }               
258        };
259
260        struct ActiveTime : public ColAdapter_t
261        {
262                virtual int compare(tD& l, tD& r)       { return hal::compare(l->active(), r->active()); }             
263                virtual std::wstring print(tD& t) 
264                { 
265                        if (!t->active().is_special())
266                        {
267                                return hal::from_utf8(
268                                        boost::posix_time::to_simple_string(t->active()));
269                        }
270                        else
271                        {
272                                return hal::app().res_wstr(HAL_INF);           
273                        }
274                }               
275        };
276       
277        struct SeedingTime : public ColAdapter_t
278        {
279                virtual int compare(tD& l, tD& r) { return hal::compare(l->seeding(), r->seeding()); }         
280                virtual std::wstring print(tD& t) 
281                { 
282                        if (!t->seeding().is_special())
283                        {
284                                return hal::from_utf8(
285                                        boost::posix_time::to_simple_string(t->seeding()));
286                        }
287                        else
288                        {
289                                return hal::app().res_wstr(HAL_INF);           
290                        }
291                }               
292        };
293       
294        struct StartTime : public ColAdapter_t
295        {
296                virtual int compare(tD& l, tD& r)       { return hal::compare(l->startTime(), r->startTime()); }               
297                virtual std::wstring print(tD& t) 
298                { 
299                        if (!t->startTime().is_special())
300                        {
301                                return hal::from_utf8(
302                                        boost::posix_time::to_simple_string(t->startTime()));
303                        }
304                        else
305                        {
306                                return hal::app().res_wstr(IDS_NA);             
307                        }
308                }               
309        };
310       
311        struct FinishTime : public ColAdapter_t
312        {
313                virtual int compare(tD& l, tD& r) { return hal::compare(l->finishTime(), r->finishTime()); }           
314                virtual std::wstring print(tD& t) 
315                { 
316                        if (!t->finishTime().is_special())
317                        {
318                                return hal::from_utf8(
319                                        boost::posix_time::to_simple_string(t->finishTime()));
320                        }
321                        else
322                        {
323                                return hal::app().res_wstr(IDS_NA);             
324                        }
325                }               
326        };
327       
328        };
329
330public:
331        enum { 
332                LISTVIEW_ID_MENU = HAL_LISTVIEW_MENU,
333                LISTVIEW_ID_COLUMNNAMES = HAL_LISTVIEW_COLUMNS,
334                LISTVIEW_ID_COLUMNWIDTHS = HAL_LISTVIEW_DEFAULTS
335        };
336
337        HaliteListViewCtrl(HaliteWindow& HalWindow);
338
339        BEGIN_MSG_MAP_EX(HaliteListViewCtrl)
340                MSG_WM_SHOWWINDOW(OnShowWindow)
341                MSG_WM_DESTROY(OnDestroy)
342
343                COMMAND_ID_HANDLER(ID__LVM_PAUSE, OnPause)
344                COMMAND_ID_HANDLER(ID_LVM_STOP, OnStop)
345                COMMAND_ID_HANDLER(ID_LVM_RESUME, OnResume)
346                COMMAND_ID_HANDLER(ID_LVM_RECHECK, OnRecheck)
347                COMMAND_ID_HANDLER(ID_LVM_REMOVE_T, OnRemove)
348                COMMAND_ID_HANDLER(ID_LVM_REMOVE_TD, OnRemoveWipeFiles)
349                COMMAND_ID_HANDLER(ID_LVM_DOWNLOAD_FOLDER, OnDownloadFolder)
350                COMMAND_ID_HANDLER(ID_LVM_EDIT_FOLDERS, OnEditFolders)
351
352                CHAIN_MSG_MAP(listClass)
353                DEFAULT_REFLECTION_HANDLER()
354        END_MSG_MAP()
355
356        void OnShowWindow(UINT, INT);
357        void OnDestroy();
358        void saveSettings();
359        void uiUpdate(const hal::torrent_details_manager& allTorrents); 
360
361        LRESULT OnPause(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
362        LRESULT OnStop(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
363        LRESULT OnResume(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
364        LRESULT OnRecheck(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
365        LRESULT OnRemoveFocused(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
366        LRESULT OnRemove(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
367        LRESULT OnRemoveWipeFiles(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
368        LRESULT OnDownloadFolder(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
369        LRESULT OnEditFolders(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);
370
371    friend class boost::serialization::access;
372    template<class Archive>
373    void serialize(Archive& ar, const unsigned int version)
374    {
375                if (version > 2)
376                        ar & boost::serialization::make_nvp("listview", 
377                                boost::serialization::base_object<listClass>(*this));
378    }
379       
380        tD CustomItemConversion(LVCompareParam* param, int iSortCol);
381
382private:
383        void OnAttach();
384        void OnDetach();
385       
386        enum { NumberOfColumns_s = 21 };
387       
388        HaliteWindow& halWindow_;
389};
390
391BOOST_CLASS_VERSION(HaliteListViewCtrl, 3)
392typedef HaliteListViewCtrl::SelectionManager ListViewManager;
393
394#endif // RC_INVOKED
Note: See TracBrowser for help on using the repository browser.