Changeset 658 for trunk


Ignore:
Timestamp:
12/26/08 18:58:24 (11 years ago)
Author:
Eoin
Message:

All sorting playing nice. Now gotta expand code to other listviews.

Location:
trunk/src
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteDialog.cpp

    r634 r658  
    213213                } 
    214214                 
    215                 ConditionallyDoAutoSort(); 
     215//              ConditionallyDoAutoSort(); 
    216216        } 
    217217} 
  • trunk/src/HaliteListView.cpp

    r657 r658  
    9292        if (lock)  
    9393        {                
    94  
    95         if (GetSortColumn() != -1) 
     94         
     95        int col_sort_index = GetSortColumn(); 
     96 
     97        // Perform external ListView sort here. 
     98        if (col_sort_index != -1) 
    9699        {                
    97                 int index = GetColumnSortType(GetSortColumn()); 
     100                int index = GetColumnSortType(col_sort_index); 
    98101                 
    99102                if (index > WTL::LVCOLSORT_LAST) 
     
    104107                tD.sort(hal::torrent_details::managed_e); 
    105108 
    106  
     109        bool sort_once = IsSortOnce(); 
     110 
     111        // Update details here. 
    107112        for (size_t td_index=0, e=tD.torrents().size(); td_index<e; ++td_index) 
    108113        { 
     
    110115         
    111116                int item_pos = td_index; 
    112  
    113                 bool a = AutoSort(); 
    114                 bool s = IsSortOnce(); 
    115117                 
    116                 HAL_DEV_MSG(hal::wform(L"AutoSort() = %1%, SortOnce() = %2%, !AutoSort() && !SortOnce() = %3%") % a % s % (!a && !s)); 
    117  
    118                 if (!a && !s) 
     118                HAL_DEV_SORT_MSG(hal::wform(L"AutoSort() = %1%, SortOnce() = %2%, !AutoSort() && !SortOnce() = %3%")  
     119                        % AutoSort() % sort_once % (!AutoSort() && !sort_once)); 
     120 
     121                if (!AutoSort() && !sort_once) 
    119122                { 
    120123                        LV_FINDINFO findInfo;  
     
    125128                } 
    126129                 
    127                 HAL_DEV_MSG(hal::wform(L"Item = %1%, Index = %2%") % td->name() % item_pos); 
     130                HAL_DEV_SORT_MSG(hal::wform(L"Item = %1%, Index = %2%") % td->name() % item_pos); 
    128131 
    129132                LVITEM lvItem = { 0 }; 
     
    162165        } 
    163166         
    164 /*      int iCol = GetSortColumn(); 
    165         if (AutoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
    166                 DoSortItems(iCol, IsSortDescending()); 
    167 */       
     167        // Perform internal ListView sort here. 
     168        if (AutoSort() && col_sort_index >= 0 && col_sort_index < m_arrColSortType.GetSize()) 
     169        { 
     170                if (GetColumnSortType(col_sort_index) <= WTL::LVCOLSORT_CUSTOM) 
     171                        DoSortItems(col_sort_index, IsSortDescending()); 
     172        } 
     173         
    168174        } 
    169175} 
  • trunk/src/HaliteSortListViewCtrl.hpp

    r657 r658  
    9696                        bool visible = listView_.OnNameChecked(wID-COL_MENU_NAMES); 
    9797 
    98                 /*      MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    99                  
    100                         minfo.fMask = MIIM_STATE; 
    101                         minfo.fState = visible ? MFS_CHECKED : MFS_UNCHECKED; 
    102                  
    103                         menu_.SetMenuItemInfo(wID, false, &minfo); 
    104                 */ 
    10598                        return 0; 
    10699                } 
     
    328321        } 
    329322 
    330 /*      LRESULT OnSortChanged(int, LPNMHDR pnmh, BOOL&) 
    331         {                
    332                 hal::try_update_lock<thisClass> lock(*this); 
    333                  
    334                 if (lock) manager_.sync_list(true, true); 
    335                  
    336                 return 0; 
    337         } 
    338 */ 
    339323        LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&) 
    340324        { 
     
    541525                return pT->CustomItemComparision(left, right, iSortCol); 
    542526        } 
    543         */ 
     527*/ 
    544528        bool AutoSort() { return auto_sort_; } 
    545529         
    546         void ConditionallyDoAutoSort() 
    547         { 
    548 /*              int iCol = GetSortColumn(); 
     530/*      void ConditionallyDoAutoSort() 
     531        { 
     532                int iCol = GetSortColumn(); 
    549533                if (AutoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
    550                         DoSortItems(iCol, IsSortDescending());  */ 
    551         } 
    552                  
     534                        DoSortItems(iCol, IsSortDescending());   
     535        } 
     536*/               
    553537        ColumnAdapter* getColumnAdapter(size_t index) 
    554538        { 
     
    584568                        return 0; 
    585569        } 
    586         */ 
     570*/ 
    587571        void regColumnAdapter(size_t key, ColumnAdapter* colAdapter) 
    588572        { 
  • trunk/src/HaliteWindow.cpp

    r641 r658  
    155155 
    156156        // Register UIEvents and the timer for the monitoring interval 
    157         SetTimer(ID_UPDATE_TIMER, 500); 
     157        SetTimer(ID_UPDATE_TIMER, 5000); 
    158158        SetTimer(ID_SAVE_TIMER, 5000); 
    159159        connectUiUpdate(bind(&HaliteWindow::updateWindow, this)); 
  • trunk/src/WTLx/ListViewSortMixin.hpp

    r657 r658  
    1111#include <winstl/controls/listview_sequence.hpp> 
    1212 
    13 #define SORTLV_USESHELLBITMAPS  0x00000001 
    14  
    1513namespace WTLx 
    1614{ 
     
    1917class ListViewSortMixin : public WTL::CSortListViewImpl<T> 
    2018{ 
     19 
    2120protected: 
    22          
    23         // Column sort types. Can be set on a per-column basis with the SetColumnSortType method. 
    24 /*      enum 
    25         { 
    26                 LVCOLSORT_NONE, 
    27                 LVCOLSORT_TEXT,   // default 
    28                 LVCOLSORT_TEXTNOCASE, 
    29                 LVCOLSORT_LONG, 
    30                 LVCOLSORT_DOUBLE, 
    31                 LVCOLSORT_DECIMAL, 
    32                 LVCOLSORT_DATETIME, 
    33                 LVCOLSORT_DATE, 
    34                 LVCOLSORT_TIME, 
    35                 LVCOLSORT_CUSTOM, 
    36                 LVCOLSORT_LAST = LVCOLSORT_CUSTOM 
    37         }; 
    38  
    39         enum 
    40         { 
    41                 m_cchCmpTextMax = 32, // overrideable 
    42                 m_cxSortImage = 16, 
    43                 m_cySortImage = 15, 
    44                 m_cxSortArrow = 11, 
    45                 m_cySortArrow = 6, 
    46                 m_iSortUp = 0,        // index of sort bitmaps 
    47                 m_iSortDown = 1, 
    48                 m_nShellSortUpID = 133 
    49         };       
    50 */ 
    5121        BEGIN_MSG_MAP(ListViewSortMixin) 
    5222                MESSAGE_HANDLER(LVM_INSERTCOLUMN, WTL::CSortListViewImpl<T>::OnInsertColumn) 
     
    5727        END_MSG_MAP() 
    5828 
    59 /*      LRESULT OnInsertColumn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& )  
    60         { 
    61                 T* pT = static_cast<T*>(this); 
    62                 LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam); 
    63                 if(lRet == -1) 
    64                         return -1; 
    65  
    66                 WORD wType = 0; 
    67                 m_arrColSortType.Add(wType); 
    68                 int nCount = m_arrColSortType.GetSize(); 
    69                 ATLASSERT(nCount == GetColumnCount()); 
    70  
    71                 for(int i = nCount - 1; i > lRet; i--) 
    72                         m_arrColSortType[i] = m_arrColSortType[i - 1]; 
    73                 m_arrColSortType[(int)lRet] = LVCOLSORT_TEXT; 
    74  
    75                 if(lRet <= m_iSortColumn) 
    76                         m_iSortColumn++; 
    77  
    78                 return lRet; 
    79         } 
    80  
    81         LRESULT OnDeleteColumn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL&)   
    82         { 
    83                 T* pT = static_cast<T*>(this); 
    84                 LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam); 
    85                 if(lRet == 0) 
    86                         return 0; 
    87  
    88                 int iCol = (int)wParam;  
    89                 if(m_iSortColumn == iCol) 
    90                         m_iSortColumn = -1; 
    91                 else if(m_iSortColumn > iCol) 
    92                         m_iSortColumn--; 
    93                 m_arrColSortType.RemoveAt(iCol); 
    94  
    95                 return lRet; 
    96         } 
    97  
    98         LRESULT OnSettingChange(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) 
    99         { 
    100 #ifndef _WIN32_WCE 
    101                 if(wParam == SPI_SETNONCLIENTMETRICS) 
    102                         GetSystemSettings(); 
    103 #else  // CE specific 
    104                 wParam; // avoid level 4 warning 
    105                 GetSystemSettings(); 
    106 #endif // _WIN32_WCE 
    107                 bHandled = FALSE; 
    108                 return 0; 
    109         } 
    110  
    111         void GetSystemSettings() 
    112         { 
    113                 if(!m_bCommCtrl6 && !m_bmSort[m_iSortUp].IsNull()) 
    114                 { 
    115                         T* pT = static_cast<T*>(this); 
    116                         pT->CreateSortBitmaps(); 
    117                         if(m_iSortColumn != -1) 
    118                                 SetSortColumn(m_iSortColumn); 
    119                 } 
    120         } 
    121 */ 
    12229        DWORD SetListViewSortMixinExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0) 
    12330        { 
     
    13037        } 
    13138 
    132         DWORD GetListViewSortMixibExtendedStyle() const 
     39        DWORD GetListViewSortMixinExtendedStyle() const 
    13340        { 
    13441                return m_dwSortLVExtendedStyle; 
    13542        } 
    13643         
    137  
    13844        void SetColumnSortType(int iCol, WORD wType) 
    13945        { 
    140                 HAL_DEV_MSG(hal::wform(L"SetColumnSortType(int iCol = %1%, WORD wType = %2%)") % iCol % wType); 
     46                HAL_DEV_SORT_MSG(hal::wform(L"SetColumnSortType(int iCol = %1%, WORD wType = %2%)") % iCol % wType); 
    14147 
    14248                ATLASSERT(iCol >= 0 && iCol < m_arrColSortType.GetSize()); 
     
    14551        } 
    14652 
    147 /*      int GetColumnCount() const 
    148         { 
    149                 const T* pT = static_cast<const T*>(this); 
    150                 ATLASSERT(::IsWindow(pT->m_hWnd)); 
    151                 WTL::CHeaderCtrl header = pT->GetHeader(); 
    152                 return header.m_hWnd != NULL ? header.GetItemCount() : 0; 
    153         } 
    154         */ 
    15553        LRESULT OnHeaderItemClick(int idCtrl, LPNMHDR pnmh, BOOL& bHandled) 
    15654        {                
    157                 HAL_DEV_MSG(hal::wform(L"OnHeaderItemClick(int idCtrl = %1%, LPNMHDR pnmh, BOOL& bHandled)") % idCtrl); 
     55                HAL_DEV_SORT_MSG(hal::wform(L"OnHeaderItemClick(int idCtrl = %1%, LPNMHDR pnmh, BOOL& bHandled)") % idCtrl); 
    15856 
    15957                LPNMHEADER p = (LPNMHEADER)pnmh; 
     
    17371        bool DoSortItems(int iCol, bool bDescending = false) 
    17472        { 
    175                 HAL_DEV_MSG(hal::wform(L"DoSortItems(int iCol = %1%, bool bDescending = %2%)") % iCol % bDescending); 
     73                HAL_DEV_SORT_MSG(hal::wform(L"DoSortItems(int iCol = %1%, bool bDescending = %2%)") % iCol % bDescending); 
    17674 
    17775                T* pT = static_cast<T*>(this); 
     
    18482                else if (wType <= WTL::LVCOLSORT_LAST) 
    18583                { 
    186                         HAL_DEV_MSG(hal::wform(L"wType = %1%, passing DoSort() to base class") % wType); 
     84                        HAL_DEV_SORT_MSG(hal::wform(L"wType = %1%, passing DoSort() to base class") % wType); 
    18785                        return WTL::CSortListViewImpl<T>::DoSortItems(iCol, bDescending); 
    18886                } 
     
    213111                return bRet; 
    214112        } 
    215 /* 
    216         void SetSortColumn(int iCol) 
    217         { 
    218                 T* pT = static_cast<T*>(this); 
    219                 ATLASSERT(::IsWindow(pT->m_hWnd)); 
    220                 WTL::CHeaderCtrl header = pT->GetHeader(); 
    221                 ATLASSERT(header.m_hWnd != NULL); 
    222                 ATLASSERT(iCol >= -1 && iCol < m_arrColSortType.GetSize()); 
    223  
    224                 int iOldSortCol = m_iSortColumn; 
    225                 m_iSortColumn = iCol; 
    226  
    227                 if(m_bCommCtrl6) 
    228                 { 
    229 #ifndef HDF_SORTUP 
    230                         const int HDF_SORTUP = 0x0400;   
    231 #endif // HDF_SORTUP 
    232 #ifndef HDF_SORTDOWN 
    233                         const int HDF_SORTDOWN = 0x0200;         
    234 #endif // HDF_SORTDOWN 
    235                         const int nMask = HDF_SORTUP | HDF_SORTDOWN; 
    236                         HDITEM hditem = { HDI_FORMAT }; 
    237                         if(iOldSortCol != iCol && iOldSortCol >= 0 && header.GetItem(iOldSortCol, &hditem)) 
    238                         { 
    239                                 hditem.fmt &= ~nMask; 
    240                                 header.SetItem(iOldSortCol, &hditem); 
    241                         } 
    242                         if(iCol >= 0 && header.GetItem(iCol, &hditem)) 
    243                         { 
    244                                 hditem.fmt &= ~nMask; 
    245                                 hditem.fmt |= m_bSortDescending ? HDF_SORTDOWN : HDF_SORTUP; 
    246                                 header.SetItem(iCol, &hditem); 
    247                         } 
    248                         return; 
    249                 } 
    250  
    251                 if(m_bmSort[m_iSortUp].IsNull()) 
    252                         pT->CreateSortBitmaps(); 
    253  
    254                 // restore previous sort column's bitmap, if any, and format 
    255                 HDITEM hditem = { HDI_BITMAP | HDI_FORMAT }; 
    256                 if(iOldSortCol != iCol && iOldSortCol >= 0) 
    257                 { 
    258                         hditem.hbm = m_hbmOldSortCol; 
    259                         hditem.fmt = m_fmtOldSortCol; 
    260                         header.SetItem(iOldSortCol, &hditem); 
    261                 } 
    262  
    263                 // save new sort column's bitmap and format, and add our sort bitmap 
    264                 if(iCol >= 0 && header.GetItem(iCol, &hditem)) 
    265                 { 
    266                         if(iOldSortCol != iCol) 
    267                         { 
    268                                 m_fmtOldSortCol = hditem.fmt; 
    269                                 m_hbmOldSortCol = hditem.hbm; 
    270                         } 
    271                         hditem.fmt &= ~HDF_IMAGE; 
    272                         hditem.fmt |= HDF_BITMAP | HDF_BITMAP_ON_RIGHT; 
    273                         int i = m_bSortDescending ? m_iSortDown : m_iSortUp; 
    274                         hditem.hbm = m_bmSort[i]; 
    275                         header.SetItem(iCol, &hditem); 
    276                 } 
    277         } 
    278  
    279         void CreateSortBitmaps() 
    280         { 
    281                 if((m_dwSortLVExtendedStyle & SORTLV_USESHELLBITMAPS) != 0) 
    282                 { 
    283                         bool bFree = false; 
    284                         LPCTSTR pszModule = _T("shell32.dll");  
    285                         HINSTANCE hShell = ::GetModuleHandle(pszModule); 
    286  
    287                         if (hShell == NULL)              
    288                         { 
    289                                 hShell = ::LoadLibrary(pszModule); 
    290                                 bFree = true; 
    291                         } 
    292   
    293                         if (hShell != NULL) 
    294                         { 
    295                                 bool bSuccess = true; 
    296                                 for(int i = m_iSortUp; i <= m_iSortDown; i++) 
    297                                 { 
    298                                         if(!m_bmSort[i].IsNull()) 
    299                                                 m_bmSort[i].DeleteObject(); 
    300                                         m_bmSort[i] = (HBITMAP)::LoadImage(hShell, MAKEINTRESOURCE(m_nShellSortUpID + i),  
    301 #ifndef _WIN32_WCE 
    302                                                 IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS); 
    303 #else // CE specific 
    304                                                 IMAGE_BITMAP, 0, 0, 0); 
    305 #endif // _WIN32_WCE 
    306                                         if(m_bmSort[i].IsNull()) 
    307                                         { 
    308                                                 bSuccess = false; 
    309                                                 break; 
    310                                         } 
    311                                 } 
    312                                 if(bFree) 
    313                                         ::FreeLibrary(hShell); 
    314                                 if(bSuccess) 
    315                                         return; 
    316                         } 
    317                 } 
    318  
    319                 T* pT = static_cast<T*>(this); 
    320                 for(int i = m_iSortUp; i <= m_iSortDown; i++) 
    321                 { 
    322                         if(!m_bmSort[i].IsNull()) 
    323                                 m_bmSort[i].DeleteObject(); 
    324  
    325                         WTL::CDC dcMem; 
    326                         WTL::CClientDC dc(::GetDesktopWindow()); 
    327                         dcMem.CreateCompatibleDC(dc.m_hDC); 
    328                         m_bmSort[i].CreateCompatibleBitmap(dc.m_hDC, m_cxSortImage, m_cySortImage); 
    329                         HBITMAP hbmOld = dcMem.SelectBitmap(m_bmSort[i]); 
    330                         RECT rc = {0,0,m_cxSortImage, m_cySortImage}; 
    331                         pT->DrawSortBitmap(dcMem.m_hDC, i, &rc); 
    332                         dcMem.SelectBitmap(hbmOld); 
    333                         dcMem.DeleteDC(); 
    334                 } 
    335         } 
    336  
    337         void DrawSortBitmap(WTL::CDCHandle dc, int iBitmap, LPRECT prc) 
    338         { 
    339                 dc.FillRect(prc, ::GetSysColorBrush(COLOR_BTNFACE));     
    340                 HBRUSH hbrOld = dc.SelectBrush(::GetSysColorBrush(COLOR_BTNSHADOW)); 
    341                 WTL::CPen pen; 
    342                 pen.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_BTNSHADOW)); 
    343                 HPEN hpenOld = dc.SelectPen(pen); 
    344                 POINT ptOrg = { (m_cxSortImage - m_cxSortArrow) / 2, (m_cySortImage - m_cySortArrow) / 2 }; 
    345                 if(iBitmap == m_iSortUp) 
    346                 { 
    347                         POINT pts[3] =  
    348                         { 
    349                                 { ptOrg.x + m_cxSortArrow / 2, ptOrg.y }, 
    350                                 { ptOrg.x, ptOrg.y + m_cySortArrow - 1 },  
    351                                 { ptOrg.x + m_cxSortArrow - 1, ptOrg.y + m_cySortArrow - 1 } 
    352                         }; 
    353                         dc.Polygon(pts, 3); 
    354                 } 
    355                 else 
    356                 { 
    357                         POINT pts[3] =  
    358                         { 
    359                                 { ptOrg.x, ptOrg.y }, 
    360                                 { ptOrg.x + m_cxSortArrow / 2, ptOrg.y + m_cySortArrow - 1 }, 
    361                                 { ptOrg.x + m_cxSortArrow - 1, ptOrg.y } 
    362                         }; 
    363                         dc.Polygon(pts, 3); 
    364                 } 
    365                 dc.SelectBrush(hbrOld); 
    366                 dc.SelectPen(hpenOld); 
    367         } 
    368  
    369         int GetSortColumn() const 
    370         { 
    371                 return m_iSortColumn; 
    372         } 
    373  
    374         void SetColumnSortType(int iCol, WORD wType) 
    375         { 
    376                 ATLASSERT(iCol >= 0 && iCol < m_arrColSortType.GetSize()); 
    377                 ATLASSERT(wType >= LVCOLSORT_NONE && wType <= LVCOLSORT_LAST); 
    378                 m_arrColSortType[iCol] = wType; 
    379         } 
    380  
    381         WORD GetColumnSortType(int iCol) const 
    382         { 
    383                 ATLASSERT((iCol >= 0) && iCol < m_arrColSortType.GetSize()); 
    384                 return m_arrColSortType[iCol]; 
    385         } 
    386  
    387         bool IsSortDescending() const 
    388         { 
    389                 return m_bSortDescending; 
    390         } 
    391  
    392 private: 
    393         bool m_bSortDescending; 
    394         bool m_bCommCtrl6; 
    395         int m_iSortColumn; 
    396         WTL::CBitmap m_bmSort[2]; 
    397         int m_fmtOldSortCol; 
    398         HBITMAP m_hbmOldSortCol; 
    399         DWORD m_dwSortLVExtendedStyle; 
    400         ATL::CSimpleArray<WORD> m_arrColSortType; 
    401         bool m_bUseWaitCursor; 
    402         */ 
    403113}; 
    404114 
  • trunk/src/advtabs/Files.cpp

    r648 r658  
    302302                } 
    303303 
    304                 list_.ConditionallyDoAutoSort(); 
     304//              list_.ConditionallyDoAutoSort(); 
    305305        } 
    306306} 
  • trunk/src/advtabs/Peers.cpp

    r507 r658  
    99#include "../HaliteWindow.hpp" 
    1010#include "../HaliteListView.hpp" 
    11  
    1211#include "../global/logger.hpp" 
    1312 
     
    5049                } 
    5150                 
     51                int col_sort_index = GetSortColumn(); 
     52 
    5253                // Add additional details 
    5354                for (hal::PeerDetails::iterator i=peerDetails_.begin(), e=peerDetails_.end(); 
     
    7879                } 
    7980                 
    80                 ConditionallyDoAutoSort(); 
     81                if (AutoSort() && col_sort_index >= 0 && col_sort_index < m_arrColSortType.GetSize()) 
     82                { 
     83                        if (GetColumnSortType(col_sort_index) <= WTL::LVCOLSORT_CUSTOM) 
     84                                DoSortItems(col_sort_index, IsSortDescending()); 
     85                } 
    8186        } 
    8287} 
  • trunk/src/halEvent.hpp

    r574 r658  
    4242#else 
    4343#       define HAL_DEV_MSG(msg) 
     44#endif 
     45 
     46#ifdef HAL_SORT_LOGGING 
     47#       define HAL_DEV_SORT_MSG(msg) \ 
     48        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( \ 
     49                        new hal::EventMsg(msg, hal::event_logger::dev)))  
     50#else 
     51#       define HAL_DEV_SORT_MSG(msg) 
    4452#endif 
    4553 
  • trunk/src/stdAfx.hpp

    r647 r658  
    2222 
    2323//#define HAL_TORRENT_STATE_LOGGING 
     24//#define HAL_SORT_LOGGING 
    2425//#define TXML_ARCHIVE_LOGGING 
    2526 
Note: See TracChangeset for help on using the changeset viewer.