source: src/HaliteListView.hpp @ 345

Revision 345, 10.2 KB checked in by Eoin, 12 years ago (diff)

Minor renaming and attempts to decouple GUI from Torrents.

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