source: trunk/src/HaliteListView.hpp @ 614

Revision 614, 24.4 KB checked in by Eoin, 11 years ago (diff)

ListView? grouping works. But a lacking on the API side means it's incompatible with sorting!

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