source: trunk/src/HaliteListView.hpp @ 654

Revision 654, 27.2 KB checked in by Eoin, 11 years ago (diff)

Sorting on the main listview now working with groups.

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