Ignore:
Timestamp:
12/26/08 11:42:57 (11 years ago)
Author:
Eoin
Message:

Classic sorting and external sorting not playing nice together.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteListView.hpp

    r656 r657  
    4848        typedef CHaliteSortListViewCtrl<thisClass, const hal::torrent_details_ptr> listClass; 
    4949        typedef WTL::CCustomDraw<thisClass> ownDrawClass; 
    50         typedef const hal::torrent_details_ptr tD; 
    5150 
    5251        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         }; 
    37252 
    37353public: 
     
    37757                LISTVIEW_ID_COLUMNWIDTHS = HAL_LISTVIEW_DEFAULTS 
    37858        }; 
    379  
    380         std::wstring get_string(int index, int subitem); 
    38159 
    38260        HaliteListViewCtrl(HaliteWindow& HalWindow); 
     
    40987        void OnShowWindow(UINT, INT); 
    41088        void OnDestroy(); 
    411         void saveSettings(); 
     89        void SaveSettings(); 
    41290        void uiUpdate(const hal::torrent_details_manager& allTorrents);  
    41391 
     
    429107        LRESULT OnAdjustQueuePosition(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
    430108        LRESULT OnQueueView(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled); 
    431  
    432         void queue_view_mode(); 
    433         bool DoSortItems(int iCol, bool bDescending = false); 
     109        LRESULT OnSortChanged(int, LPNMHDR pnmh, BOOL&); 
    434110 
    435111    friend class boost::serialization::access; 
     
    446122    } 
    447123 
    448 /*      tD CustomItemConversion(LVCompareParam* param, int iSortCol); 
    449  
    450         int CompareItemsCustom(LVCompareParam* pItem1, LVCompareParam* pItem2, int iSortCol) 
    451         { 
    452                 hal::mutex_update_lock<listClass> lock(*this); 
    453                  
    454                 tD left = CustomItemConversion(pItem1, iSortCol); 
    455                 tD right = CustomItemConversion(pItem2, iSortCol); 
    456                  
    457                 return CustomItemComparision(left, right, iSortCol); 
    458         }*/ 
    459  
    460         LRESULT OnSortChanged(int, LPNMHDR pnmh, BOOL&); 
    461  
    462124private: 
    463         void OnAttach(); 
    464         void OnDetach(); 
     125        void queue_view_mode(); 
     126        bool queue_view_; 
    465127         
    466128        enum { NumberOfColumns_s = 23 }; 
    467  
    468129        std::vector<const hal::torrent_details_ptr> data_elements_; 
    469130         
    470         HaliteWindow& halWindow_; 
    471         bool queue_view_; 
     131        HaliteWindow& halite_window_; 
    472132}; 
    473133 
Note: See TracChangeset for help on using the changeset viewer.