source: trunk/src/HaliteListView.hpp @ 384

Revision 384, 21.0 KB checked in by Eoin, 12 years ago (diff)

Added 'Open Download Folder'.

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