source: trunk/src/HaliteListView.hpp @ 447

Revision 447, 21.7 KB checked in by Eoin, 12 years ago (diff)

Cleaned up the SortListView? class.

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