Changeset 657


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

Classic sorting and external sorting not playing nice together.

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteListView.cpp

    r656 r657  
    2222 
    2323HaliteListViewCtrl::HaliteListViewCtrl(HaliteWindow& HalWindow) : 
    24         halWindow_(HalWindow), 
     24        halite_window_(HalWindow), 
    2525        iniClass("listviews/halite", "HaliteListView"), 
    2626        queue_view_(false) 
     
    5454                SetColumnSortType(i, i + (WTL::LVCOLSORT_LAST+1+hal::torrent_details::name_e), NULL); 
    5555         
     56        SetColumnSortType(0, WTL::LVCOLSORT_TEXTNOCASE, NULL); 
     57         
    5658        queue_view_mode(); 
    5759} 
    5860 
    59 std::wstring HaliteListViewCtrl::get_string(int index, int subitem) 
    60 { 
    61         //switch 
    62         return L""; 
    63 } 
    64  
    6561void HaliteListViewCtrl::OnDestroy() 
    6662{ 
    67         saveSettings(); 
    68 } 
    69  
    70 void HaliteListViewCtrl::saveSettings() 
     63        SaveSettings(); 
     64} 
     65 
     66void HaliteListViewCtrl::SaveSettings() 
    7167{ 
    7268        GetListViewDetails(); 
     
    9591        hal::try_update_lock<listClass> lock(*this); 
    9692        if (lock)  
    97         { 
     93        {                
     94 
     95        if (GetSortColumn() != -1) 
     96        {                
     97                int index = GetColumnSortType(GetSortColumn()); 
    9898                 
    99                 int iCol = GetSortColumn(); 
    100                 //HAL_DEV_MSG(hal::wform(L"GetSortColumn with: %1%") % iCol); 
    101  
    102                 if (iCol != -1) 
    103                 { 
     99                if (index > WTL::LVCOLSORT_LAST) 
     100                        tD.sort(index - (WTL::LVCOLSORT_LAST+1+hal::torrent_details::name_e), IsSortDescending()); 
     101        } 
     102 
     103        if (IsGroupViewEnabled()) 
     104                tD.sort(hal::torrent_details::managed_e); 
     105 
     106 
     107        for (size_t td_index=0, e=tD.torrents().size(); td_index<e; ++td_index) 
     108        { 
     109                hal::torrent_details_ptr td = tD.torrents()[td_index]; 
     110         
     111                int item_pos = td_index; 
     112 
     113                bool a = AutoSort(); 
     114                bool s = IsSortOnce(); 
     115                 
     116                HAL_DEV_MSG(hal::wform(L"AutoSort() = %1%, SortOnce() = %2%, !AutoSort() && !SortOnce() = %3%") % a % s % (!a && !s)); 
     117 
     118                if (!a && !s) 
     119                { 
     120                        LV_FINDINFO findInfo;  
     121                        findInfo.flags = LVFI_STRING; 
     122                        findInfo.psz = const_cast<LPTSTR>(td->name().c_str()); 
    104123                         
    105                         int index = GetColumnSortType(iCol); 
    106                          
    107                         if (index > WTL::LVCOLSORT_LAST) 
    108                         { 
    109                         HAL_DEV_MSG(hal::wform(L"Sorting with: %1%, %2%") % index % (index - (WTL::LVCOLSORT_LAST+1+hal::torrent_details::name_e)) ); 
    110                         tD.sort(index - (WTL::LVCOLSORT_LAST+1+hal::torrent_details::name_e), IsSortDescending()); 
    111                         } 
    112                 } 
    113  
    114                 if (IsGroupViewEnabled()) 
    115                         tD.sort(hal::torrent_details::managed_e); 
    116  
    117 #       if 0 
    118         if (GetItemCount() > 0) 
    119         { 
    120                 LVITEM lvItem = { 0 }; 
    121                 lvItem.mask = LVIF_TEXT|LVIF_GROUPID|LVIF_COLUMNS; 
    122                 lvItem.iItem = 0; 
    123                 lvItem.iSubItem = 0; 
    124  
    125                 hal::win_c_str<std::wstring> str(2048); 
    126  
    127                 lvItem.pszText = str; 
    128                 lvItem.cchTextMax = str.size(); 
    129  
    130                 GetItem(&lvItem); 
    131                 DeleteItem(lvItem.iItem); 
    132  
    133                 lvItem.iItem = GetItemCount(); 
    134                 InsertItem(&lvItem); 
    135         } 
    136 #       endif 
    137  
    138         for (size_t td_index=0, e=tD.torrents().size(); td_index<e; ++td_index) 
    139         { 
    140                 hal::torrent_details_ptr td = tD.torrents()[td_index]; 
    141                 /*LV_FINDINFO findInfo;  
    142                 findInfo.flags = LVFI_STRING; 
    143                 findInfo.psz = const_cast<LPTSTR>(td->name().c_str()); 
     124                        item_pos = FindItem(&findInfo, -1); 
     125                } 
    144126                 
    145                 int itemPos = FindItem(&findInfo, -1); 
    146                 */ 
     127                HAL_DEV_MSG(hal::wform(L"Item = %1%, Index = %2%") % td->name() % item_pos); 
    147128 
    148129                LVITEM lvItem = { 0 }; 
     
    164145                lvItem.iImage = 0; 
    165146 
    166                 if (GetItemCount() <= static_cast<int>(td_index)) 
     147                if (item_pos < 0 || GetItemCount() <= static_cast<int>(item_pos)) 
    167148                { 
    168149                        lvItem.iItem = GetItemCount(); 
     
    171152                else 
    172153                { 
    173                         lvItem.iItem = td_index; 
     154                        lvItem.iItem = item_pos; 
    174155                        SetItem(&lvItem); 
    175156                } 
     
    177158                for (size_t i=1; i<NumberOfColumns_s; ++i) 
    178159                { 
    179                         SetItemText(td_index, i, td->to_wstring(i).c_str()); 
     160                        SetItemText(item_pos, i, td->to_wstring(i).c_str()); 
    180161                } 
    181162        } 
    182163         
    183164/*      int iCol = GetSortColumn(); 
    184         if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
     165        if (AutoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
    185166                DoSortItems(iCol, IsSortDescending()); 
    186167*/       
     
    188169} 
    189170 
    190 bool HaliteListViewCtrl::DoSortItems(int iCol, bool bDescending) 
    191 {        
    192         HAL_DEV_MSG(hal::wform(L"DoSortItems(int iCol = %1%, bool bDescending = %2%) - issuing update!") % iCol % bDescending); 
    193  
    194         halWindow_.issueUiUpdate(); 
    195  
    196         return true; 
    197 } 
    198  
    199171LRESULT HaliteListViewCtrl::OnSortChanged(int, LPNMHDR pnmh, BOOL&) 
    200 {                
    201         halWindow_.issueUiUpdate(); 
     172{ 
     173        halite_window_.issueUiUpdate(); 
    202174         
    203175        return 0; 
     
    371343        } 
    372344        DeleteAllItems(); 
    373         halWindow_.issueUiUpdate(); 
     345        halite_window_.issueUiUpdate(); 
    374346 
    375347        return 0; 
     
    383355        } 
    384356        DeleteAllItems(); 
    385         halWindow_.issueUiUpdate(); 
     357        halite_window_.issueUiUpdate(); 
    386358 
    387359        return 0; 
     
    411383        } 
    412384 
    413         halWindow_.issueUiUpdate(); 
     385        halite_window_.issueUiUpdate(); 
    414386         
    415387        return 0; 
     
    470442                int ret = EnableGroupView(false); 
    471443        } 
    472         halWindow_.issueUiUpdate(); 
     444        halite_window_.issueUiUpdate(); 
    473445 
    474446        MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
  • 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 
  • trunk/src/HaliteListViewCtrl.hpp

    r573 r657  
    393393        sortDirection sortingDirection() { return sortingDirection_; } 
    394394         
    395         std::vector<int>& listColumnWidth() { return listColumnWidth_; } 
    396         std::vector<int>& listColumnOrder() { return listColumnOrder_; } 
    397          
    398         const std::vector<int>& listColumnWidth() const { return listColumnWidth_; } 
    399         const std::vector<int>& listColumnOrder() const { return listColumnOrder_; } 
     395        std::vector<int>& ListColumnWidth() { return listColumnWidth_; } 
     396        std::vector<int>& ListColumnOrder() { return listColumnOrder_; } 
     397         
     398        const std::vector<int>& ListColumnWidth() const { return listColumnWidth_; } 
     399        const std::vector<int>& ListColumnOrder() const { return listColumnOrder_; } 
    400400         
    401401private: 
  • trunk/src/HaliteSortListViewCtrl.hpp

    r656 r657  
    130130                header_(*this), 
    131131                update_lock_(0), 
    132                 autoSort_(false), 
     132                auto_sort_(false), 
    133133                descending_(false), 
    134134                sortCol_(-1) 
     
    187187        }                
    188188         
    189 /*      template<typename N, typename W, typename O, typename P> 
    190         void SetDefaults(N nameList, W widthList, O orderList, P visibleList, bool autoSort=false) 
    191         { 
    192                 listNames_.assign(nameList.begin(), nameList.end()); 
    193                 listWidths_.assign(widthList.begin(), widthList.end()); 
    194                 listOrder_.assign(orderList.begin(), orderList.end()); 
    195                 listVisible_.assign(visibleList.begin(), visibleList.end()); 
    196                  
    197                 autoSort_ = autoSort; 
    198         } 
    199 */ 
    200189        void SafeLoadFromIni() 
    201190        { 
     
    205194                std::vector<bool> listVisible; 
    206195 
    207                 listNames.assign(listNames_.begin(), listNames_.end()); 
    208                 listWidths.assign(listWidths_.begin(), listWidths_.end()); 
    209                 listOrder.assign(listOrder_.begin(), listOrder_.end()); 
    210                 listVisible.assign(listVisible_.begin(), listVisible_.end()); 
     196                listNames.assign(list_names_.begin(), list_names_.end()); 
     197                listWidths.assign(list_widths_.begin(), list_widths_.end()); 
     198                listOrder.assign(list_order_.begin(), list_order_.end()); 
     199                listVisible.assign(list_visible_.begin(), list_visible_.end()); 
    211200 
    212201                TBase* pT = static_cast<TBase*>(this); 
    213                 if (!pT->load_from_ini() || !vectorSizePreConditions()) 
    214                 { 
    215                         listNames_.assign(listNames.begin(), listNames.end()); 
    216                         listWidths_.assign(listWidths.begin(), listWidths.end()); 
    217                         listOrder_.assign(listOrder.begin(), listOrder.end()); 
    218                         listVisible_.assign(listVisible.begin(), listVisible.end()); 
     202                if (!pT->load_from_ini() || !vector_size_pre_conditions()) 
     203                { 
     204                        list_names_.assign(listNames.begin(), listNames.end()); 
     205                        list_widths_.assign(listWidths.begin(), listWidths.end()); 
     206                        list_order_.assign(listOrder.begin(), listOrder.end()); 
     207                        list_visible_.assign(listVisible.begin(), listVisible.end()); 
    219208                }                
    220209        } 
    221 /*       
    222         void ApplyDetails() 
    223         { 
    224                 vectorSizePreConditions(); 
    225                  
     210 
     211        void InitialSetup(WTL::CMenuHandle menu=WTL::CMenuHandle()) 
     212        { 
     213                SetExtendedListViewStyle(LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER); 
     214                SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS,SORTLV_USESHELLBITMAPS); 
     215 
    226216                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    227217                 
    228                 if (!menu_) 
     218                if (!menu) 
    229219                { 
    230220                        menu_.CreatePopupMenu(); 
    231221                } 
    232222                else 
    233                 {                                
     223                {                
     224                        menu_.Attach(menu.GetSubMenu(0)); 
     225 
    234226                        minfo.fMask = MIIM_SUBMENU; 
    235227                        minfo.fType = MFT_SEPARATOR; 
     
    240232                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE; 
    241233                minfo.fType = MFT_STRING; 
    242                 minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
    243                 minfo.wID = ID_LVM_AUTOSORT; 
    244                  
    245                 wstring autoarrange = hal::app().res_wstr(HAL_AUTOSORT); 
    246                 minfo.dwTypeData = (LPWSTR)autoarrange.c_str(); 
    247                  
    248                 menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo); 
    249                  
    250                 header_.Attach(this->GetHeader()); 
    251                 header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG); 
    252  
    253                 header_.Menu().CreatePopupMenu(); 
    254  
    255                 for (int i=header_.GetItemCount(), e=int(listNames_.size()); i<e; ++i) 
    256                 { 
    257                         MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    258                         minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE; 
    259                         minfo.fType = MFT_STRING; 
    260                         minfo.dwTypeData = (LPWSTR)listNames_[i].c_str(); 
    261                         minfo.wID = CHaliteHeaderCtrl::COL_MENU_NAMES+i; 
    262  
    263                         AddColumn(listNames_[i].c_str(), i); 
    264  
    265                         if (listVisible_[i]) 
    266                         { 
    267                                 minfo.fState = MFS_CHECKED;                      
    268                                 SetColumnWidth(i, listWidths_[i]); 
    269                         } 
    270                         else 
    271                         { 
    272                                 minfo.fState = MFS_UNCHECKED; 
    273                                 SetColumnWidth(i, 0); 
    274                         } 
    275  
    276                         header_.Menu().InsertMenuItem(header_.Menu().GetMenuItemCount(), false, &minfo); 
    277                 } 
    278                  
    279                 SetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
    280                  
    281                 m_bSortDescending = descending_; 
    282                 if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize()) 
    283                         SetSortColumn(sortCol_); 
    284         } 
    285 */ 
    286         void InitialSetup(WTL::CMenuHandle menu=WTL::CMenuHandle()) 
    287         { 
    288                 SetExtendedListViewStyle(LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER); 
    289                 SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS,SORTLV_USESHELLBITMAPS); 
    290  
    291                 MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    292                  
    293                 if (!menu) 
    294                 { 
    295                         menu_.CreatePopupMenu(); 
    296                 } 
    297                 else 
    298                 {                
    299                         menu_.Attach(menu.GetSubMenu(0)); 
    300  
    301                         minfo.fMask = MIIM_SUBMENU; 
    302                         minfo.fType = MFT_SEPARATOR; 
    303                          
    304                         menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);            
    305                 } 
    306  
    307                 minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE; 
    308                 minfo.fType = MFT_STRING; 
    309                 minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
     234                minfo.fState = auto_sort_ ? MFS_CHECKED : MFS_UNCHECKED; 
    310235                minfo.wID = ID_LVM_AUTOSORT; 
    311236                 
     
    323248        void GetListViewDetails() 
    324249        { 
    325                 vectorSizePreConditions();               
    326                  
    327                 for (size_t i=0; i<listNames_.size(); ++i) 
    328                 { 
    329                         if (listVisible_[i]) 
    330                                 listWidths_[i] = GetColumnWidth(i); 
    331                 } 
    332                  
    333                 GetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
    334                  
    335 /*              sortCol_ = GetSortColumn(); 
    336                 descending_ = IsSortDescending();       */ 
     250                vector_size_pre_conditions();            
     251                 
     252                for (size_t i=0; i<list_names_.size(); ++i) 
     253                { 
     254                        if (list_visible_[i]) 
     255                                list_widths_[i] = GetColumnWidth(i); 
     256                } 
     257                 
     258                GetColumnOrderArray(list_names_.size(), &list_order_[0]); 
     259                 
     260                sortCol_ = GetSortColumn(); 
     261                descending_ = IsSortDescending();        
    337262        } 
    338263         
    339264        LRESULT OnAutoSort(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    340265        { 
    341                 autoSort_ = !autoSort_; 
     266                auto_sort_ = !auto_sort_; 
    342267                 
    343268                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    344269                 
    345270                minfo.fMask = MIIM_STATE; 
    346                 minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
     271                minfo.fState = auto_sort_ ? MFS_CHECKED : MFS_UNCHECKED; 
    347272                 
    348273                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo); 
     
    353278        bool OnNameChecked(int i) 
    354279        { 
    355                 if (!listVisible_[i]) 
     280                if (!list_visible_[i]) 
    356281                {                
    357                         GetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
    358                         SetColumnWidth(i, listWidths_[i]); 
    359  
    360                         listOrder_.erase(std::find(listOrder_.begin(), listOrder_.end(), i)); 
     282                        GetColumnOrderArray(list_names_.size(), &list_order_[0]); 
     283                        SetColumnWidth(i, list_widths_[i]); 
     284 
     285                        list_order_.erase(std::find(list_order_.begin(), list_order_.end(), i)); 
    361286                         
    362                         int index = i + std::count(listVisible_.begin()+i, listVisible_.end(), false) - 1; 
    363                         listOrder_.insert(listOrder_.begin()+index, i); 
    364  
    365                         SetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
    366                         listVisible_[i] = true; 
     287                        int index = i + std::count(list_visible_.begin()+i, list_visible_.end(), false) - 1; 
     288                        list_order_.insert(list_order_.begin()+index, i); 
     289 
     290                        SetColumnOrderArray(list_names_.size(), &list_order_[0]); 
     291                        list_visible_[i] = true; 
    367292                } 
    368293                else 
    369294                { 
    370                         listWidths_[i] = GetColumnWidth(i);      
    371                         GetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
     295                        list_widths_[i] = GetColumnWidth(i);     
     296                        GetColumnOrderArray(list_names_.size(), &list_order_[0]); 
    372297 
    373298                        SetColumnWidth(i, 0); 
    374299 
    375                         listOrder_.erase(std::find(listOrder_.begin(), listOrder_.end(), i)); 
    376                         listOrder_.insert(listOrder_.begin(), i); 
    377  
    378                         SetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
    379                         listVisible_[i] = false; 
     300                        list_order_.erase(std::find(list_order_.begin(), list_order_.end(), i)); 
     301                        list_order_.insert(list_order_.begin(), i); 
     302 
     303                        SetColumnOrderArray(list_names_.size(), &list_order_[0]); 
     304                        list_visible_[i] = false; 
    380305                } 
    381306                 
    382307                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};     
    383308                minfo.fMask = MIIM_STATE; 
    384                 minfo.fState = listVisible_[i] ? MFS_CHECKED : MFS_UNCHECKED;    
     309                minfo.fState = list_visible_[i] ? MFS_CHECKED : MFS_UNCHECKED;   
    385310                header_.Menu().SetMenuItemInfo(CHaliteHeaderCtrl::COL_MENU_NAMES+i, false, &minfo); 
    386311         
    387312                InvalidateRect(NULL, true); 
    388                 return listVisible_[i]; 
     313                return list_visible_[i]; 
    389314        } 
    390315 
     
    437362        } 
    438363 
    439         void SortByColumn(size_t column_index) 
    440         { 
    441                 /* Overwriteable */ 
    442         } 
    443  
    444         bool DoSortItems(int iCol, bool bDescending = false) 
    445         { 
     364        bool DoSortItemsExternal(int iCol, bool bDescending = false) 
     365        { 
     366                HAL_DEV_MSG(hal::wform(L"sort_once_ = %1%") % sort_once_); 
     367 
     368                sort_once_ = true; 
     369 
     370                return true; 
     371        } 
     372         
     373        bool IsSortOnce(bool mod_value =  true)  
     374        {  
     375                if (!sort_once_) 
     376                        return false;  
     377 
     378                if (mod_value) sort_once_ = false; 
    446379                return true; 
    447380        } 
     
    485418                int w = GetColumnWidth(i); 
    486419 
    487                 listNames_.push_back(strItem); 
    488                 listVisible_.push_back(visible); 
    489                 listWidths_.push_back(w); 
    490                 listOrder_.push_back(i); 
     420                list_names_.push_back(strItem); 
     421                list_visible_.push_back(visible); 
     422                list_widths_.push_back(w); 
     423                list_order_.push_back(i); 
    491424 
    492425                menu.InsertMenuItem(menu.GetMenuItemCount(), false, &minfo); 
     
    504437        void SetColumnOrderState() 
    505438        { 
    506                 while ((int)listOrder_.size() < header_.GetItemCount()) 
    507                         listOrder_.push_back(header_.GetItemCount()); 
    508  
    509                 GetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
     439                while ((int)list_order_.size() < header_.GetItemCount()) 
     440                        list_order_.push_back(header_.GetItemCount()); 
     441 
     442                GetColumnOrderArray(list_order_.size(), &list_order_[0]); 
    510443        } 
    511444 
     
    515448                 
    516449                minfo.fMask = MIIM_STATE; 
    517                 minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
     450                minfo.fState = auto_sort_ ? MFS_CHECKED : MFS_UNCHECKED; 
    518451                 
    519452                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo); 
     
    527460    void save(Archive & ar, const unsigned int version) const 
    528461    { 
    529                 for (size_t i=0; i<listWidths_.size(); ++i) 
    530                 { 
    531                         if (listVisible_[i]) 
    532                                 listWidths_[i] = GetColumnWidth(i); 
    533                 } 
    534  
    535                 GetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
    536 //              sortCol_ = GetSortColumn(); 
    537 //              descending_ = IsSortDescending();        
     462                for (size_t i=0; i<list_widths_.size(); ++i) 
     463                { 
     464                        if (list_visible_[i]) 
     465                                list_widths_[i] = GetColumnWidth(i); 
     466                } 
     467 
     468                GetColumnOrderArray(list_order_.size(), &list_order_[0]); 
     469                sortCol_ = GetSortColumn(); 
     470                descending_ = IsSortDescending();        
    538471 
    539472                using boost::serialization::make_nvp; 
    540473 
    541                 ar & make_nvp("width", listWidths_); 
    542                 ar & make_nvp("order", listOrder_); 
    543                 ar & make_nvp("visible", listVisible_); 
    544                 ar & make_nvp("autoSort", autoSort_); 
     474                ar & make_nvp("width", list_widths_); 
     475                ar & make_nvp("order", list_order_); 
     476                ar & make_nvp("visible", list_visible_); 
     477                ar & make_nvp("autoSort", auto_sort_); 
    545478 
    546479                ar & make_nvp("descending", descending_); 
     
    553486                using boost::serialization::make_nvp; 
    554487 
    555                 ar & make_nvp("width", listWidths_); 
    556                 ar & make_nvp("order", listOrder_); 
    557                 ar & make_nvp("visible", listVisible_); 
    558                 ar & make_nvp("autoSort", autoSort_); 
     488                ar & make_nvp("width", list_widths_); 
     489                ar & make_nvp("order", list_order_); 
     490                ar & make_nvp("visible", list_visible_); 
     491                ar & make_nvp("autoSort", auto_sort_); 
    559492 
    560493                ar & make_nvp("descending", descending_); 
    561494                ar & make_nvp("sortCol", sortCol_); 
    562495                 
    563                 SetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
    564  
    565 /*              m_bSortDescending = descending_; 
     496                SetColumnOrderArray(list_order_.size(), &list_order_[0]); 
     497 
     498                m_bSortDescending = descending_; 
    566499                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize()) 
    567500                        SetSortColumn(sortCol_); 
    568 */ 
    569                 for (size_t i=0; i<listWidths_.size(); ++i) 
    570                 { 
    571                         SetColumnWidth(i, listWidths_[i]); 
    572                         if (!listVisible_[i]) 
     501 
     502                for (size_t i=0; i<list_widths_.size(); ++i) 
     503                { 
     504                        SetColumnWidth(i, list_widths_[i]); 
     505                        if (!list_visible_[i]) 
    573506                        { 
    574                                 listVisible_[i] = true; 
     507                                list_visible_[i] = true; 
    575508                                OnNameChecked(i); 
    576509                        } 
    577510                } 
    578511 
    579 //              SetColumnOrderState(); 
    580 //              SetSortState(); 
     512                SetColumnOrderState(); 
     513                SetSortState(); 
    581514    } 
    582515 
     
    585518        const SelectionManager& manager() { return manager_; } 
    586519                 
    587         std::vector<int>& listColumnWidth() { return listColumnWidth_; } 
    588         std::vector<int>& listColumnOrder() { return listColumnOrder_; } 
    589          
    590         const std::vector<int>& listColumnWidth() const { return listColumnWidth_; } 
    591         const std::vector<int>& listColumnOrder() const { return listColumnOrder_; } 
    592          
    593         bool canUpdate() const { return updateLock_ == 0; } 
     520        std::vector<int>& ListColumnWidth() { return listColumnWidth_; } 
     521        std::vector<int>& ListColumnOrder() { return listColumnOrder_; } 
     522         
     523        const std::vector<int>& ListColumnWidth() const { return listColumnWidth_; } 
     524        const std::vector<int>& ListColumnOrder() const { return listColumnOrder_; } 
     525         
     526        bool CanUpdate() const { return updateLock_ == 0; } 
    594527         
    595528        void clearFocused() { manager_.clear(); } 
     
    609542        } 
    610543        */ 
    611         bool autoSort() { return autoSort_; } 
     544        bool AutoSort() { return auto_sort_; } 
    612545         
    613546        void ConditionallyDoAutoSort() 
    614547        { 
    615548/*              int iCol = GetSortColumn(); 
    616                 if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
     549                if (AutoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
    617550                        DoSortItems(iCol, IsSortDescending());  */ 
    618551        } 
     
    621554        { 
    622555                boost::ptr_map<size_t, ColumnAdapter>::iterator  
    623                         i = columnAdapters_.find(index); 
    624          
    625                 if (i != columnAdapters_.end()) 
     556                        i = column_adapters_.find(index); 
     557         
     558                if (i != column_adapters_.end()) 
    626559                { 
    627560                        return i->second; 
     
    655588        { 
    656589                assert (colAdapter); 
    657                 columnAdapters_.insert(key, colAdapter); 
     590                column_adapters_.insert(key, colAdapter); 
    658591        } 
    659592 
     
    666599         
    667600private: 
    668         bool vectorSizePreConditions() 
    669         { 
    670                 bool ret = (listNames_.size() == listWidths_.size()) && 
    671                         (listNames_.size() == listOrder_.size()) && 
    672                         (listNames_.size() == listVisible_.size()); 
     601        bool vector_size_pre_conditions() 
     602        { 
     603                bool ret = (list_names_.size() == list_widths_.size()) && 
     604                        (list_names_.size() == list_order_.size()) && 
     605                        (list_names_.size() == list_visible_.size()); 
    673606 
    674607                return ret; 
    675608        }        
    676609         
    677         mutable std::vector<wstring> listNames_; 
    678         mutable std::vector<int> listWidths_; 
    679         mutable std::vector<int> listOrder_; 
    680         mutable std::vector<bool> listVisible_; 
    681         mutable bool autoSort_; 
     610        mutable std::vector<wstring> list_names_; 
     611        mutable std::vector<int> list_widths_; 
     612        mutable std::vector<int> list_order_; 
     613        mutable std::vector<bool> list_visible_; 
     614 
     615        mutable bool auto_sort_; 
     616        mutable bool sort_once_; 
    682617        mutable bool descending_; 
    683618        mutable int sortCol_; 
     
    689624        friend class hal::try_update_lock<thisClass>;            
    690625         
    691         boost::ptr_map<size_t, ColumnAdapter> columnAdapters_; 
    692          
    693         WinAPIWaitableTimer syncTimer_; 
     626        boost::ptr_map<size_t, ColumnAdapter> column_adapters_; 
    694627}; 
    695628 
  • trunk/src/WTLx/ListViewSortMixin.hpp

    r656 r657  
    200200                        waitCursor.Set(); 
    201201 
    202                 bool bRet = pT->DoSortItems(iCol, bDescending); 
     202                bool bRet = pT->DoSortItemsExternal(iCol, bDescending); 
    203203 
    204204                if(bRet) 
Note: See TracChangeset for help on using the changeset viewer.