source: trunk/src/HaliteListView.hpp @ 531

Revision 531, 23.3 KB checked in by Eoin, 11 years ago (diff)

Switched trunk to hal::wform.

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