source: trunk/src/HaliteSortListViewCtrl.hpp @ 651

Revision 651, 18.0 KB checked in by Eoin, 11 years ago (diff)

Disabled sorting so to replace it with own code.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2008.
3// Distributed under the Boost Software License, Version 1.0.
4//    (See accompanying file LICENSE_1_0.txt or copy at
5//          http://www.boost.org/LICENSE_1_0.txt)
6
7#pragma once
8
9#include "stdAfx.hpp"
10
11#include <functional>
12
13#include <boost/array.hpp>
14#include <boost/signals.hpp>
15#include <boost/algorithm/string/split.hpp>
16#include <boost/ptr_container/ptr_map.hpp>
17
18#include <winstl/controls/listview_sequence.hpp>
19
20#include "Halite.hpp"
21#include "halTorrent.hpp"
22#include "halEvent.hpp"
23#include "WinAPIWaitableTimer.hpp"
24
25#include "UxthemeWrapper.hpp"
26
27#define LVS_EX_DOUBLEBUFFER     0x00010000
28
29#include "WTLx/SelectionManager.hpp"
30#include "WTLx/ListViewIterators.hpp"
31#include "HaliteUpdateLock.hpp"
32
33namespace hal
34{
35
36template<typename T>
37int compare(const T& l, const T& r)
38{
39        if (l == r) 
40                return 0;
41        else if (l > r) 
42                return 1;
43        else 
44                return -1;
45}
46
47}
48
49template <class TBase, typename AdapterType=void*>
50class CHaliteSortListViewCtrl : 
51        public ATL::CWindowImpl<TBase, WTL::CListViewCtrl>,
52        public WTLx::ListViewIterators<CHaliteSortListViewCtrl<TBase, AdapterType> >
53{
54public:
55        typedef CHaliteSortListViewCtrl<TBase, AdapterType> thisClass;
56        typedef ATL::CWindowImpl<TBase, WTL::CListViewCtrl> parentClass;
57       
58        class CHaliteHeaderCtrl : public CWindowImpl<CHaliteHeaderCtrl, WTL::CHeaderCtrl>
59        {
60        public:
61                enum { COL_MENU_NAMES = 123, COL_MAX_NAMES = 256};
62
63                CHaliteHeaderCtrl(thisClass& listView) :
64                        listView_(listView)
65                {}
66
67                BEGIN_MSG_MAP(CHaliteHeaderCtrl)
68                        REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick)
69                        COMMAND_RANGE_HANDLER(COL_MENU_NAMES, COL_MENU_NAMES+COL_MAX_NAMES, OnMenuNames)
70
71                        DEFAULT_REFLECTION_HANDLER()
72                END_MSG_MAP()
73               
74                void Attach(HWND hWndNew)
75                {
76                        ATLASSERT(::IsWindow(hWndNew));
77                        CWindowImpl<CHaliteHeaderCtrl, WTL::CHeaderCtrl>::SubclassWindow(hWndNew);
78                }
79               
80                LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&)
81                {
82                        POINT ptPoint;
83                        GetCursorPos(&ptPoint);
84                        menu_.TrackPopupMenu(0, ptPoint.x, ptPoint.y, m_hWnd);
85
86                        return 0;
87                }
88
89                LRESULT OnMenuNames(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
90                {               
91                        ATLASSERT(wID-COL_MENU_NAMES <= GetItemCount());
92
93                        bool visible = listView_.OnNameChecked(wID-COL_MENU_NAMES);
94
95                /*      MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
96               
97                        minfo.fMask = MIIM_STATE;
98                        minfo.fState = visible ? MFS_CHECKED : MFS_UNCHECKED;
99               
100                        menu_.SetMenuItemInfo(wID, false, &minfo);*/
101
102                        return 0;
103                }
104
105                WTL::CMenu& Menu()
106                {
107                        return menu_;
108                }
109               
110        private:
111                WTL::CMenu menu_;
112                thisClass& listView_;
113        };
114       
115        struct ColumnAdapter
116        {
117                virtual int compare(AdapterType& l, AdapterType& r) = 0;
118                virtual std::wstring print(AdapterType& t) = 0;
119        };
120
121public:
122        typedef WTLx::selection_manager<thisClass, std::wstring> SelectionManager;
123        typedef SelectionManager selection_manage_class;
124       
125        thisClass() :
126                manager_(*this),
127                header_(*this),
128                update_lock_(0),
129                autoSort_(false),
130                descending_(false),
131                sortCol_(-1)
132        {               
133                if (TBase::LISTVIEW_ID_MENU)
134                {
135                        WTL::CMenuHandle menu;
136                        BOOL menu_created = menu.LoadMenu(TBase::LISTVIEW_ID_MENU);
137                        assert(menu_created);   
138                       
139                        menu_.Attach(menu.GetSubMenu(0));
140                }
141        }
142
143        BEGIN_MSG_MAP_EX(thisClass)
144                COMMAND_ID_HANDLER(ID_LVM_AUTOSORT, OnAutoSort)
145               
146                REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick)
147                REFLECTED_NOTIFY_CODE_HANDLER(LVN_ITEMCHANGED, OnItemChanged)
148
149                DEFAULT_REFLECTION_HANDLER()
150//              CHAIN_MSG_MAP(parentClass)
151        END_MSG_MAP()
152
153        void Attach(HWND hWndNew)
154        {
155                ATLASSERT(::IsWindow(hWndNew));
156        parentClass::SubclassWindow(hWndNew);
157
158                TBase* pT = static_cast<TBase*>(this);
159                pT->OnAttach();
160        }
161       
162        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
163                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
164                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
165        {
166                HWND hwnd = parentClass::Create(hWndParent, 
167                        (RECT &)rect.m_lpRect, szWindowName, dwStyle, dwExStyle, (UINT)MenuOrID.m_hMenu, lpCreateParam);
168                       
169                SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER|LVS_EX_SUBITEMIMAGES);
170//              SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS);
171               
172                return hwnd;
173        }
174       
175        bool SubclassWindow(HWND hwnd)
176        {
177                if(!parentClass::SubclassWindow(hwnd))
178                        return false;
179                       
180                SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER);
181//              SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS);
182               
183                return true;
184        }               
185       
186/*      template<typename N, typename W, typename O, typename P>
187        void SetDefaults(N nameList, W widthList, O orderList, P visibleList, bool autoSort=false)
188        {
189                listNames_.assign(nameList.begin(), nameList.end());
190                listWidths_.assign(widthList.begin(), widthList.end());
191                listOrder_.assign(orderList.begin(), orderList.end());
192                listVisible_.assign(visibleList.begin(), visibleList.end());
193               
194                autoSort_ = autoSort;
195        }
196*/
197        void SafeLoadFromIni()
198        {
199                std::vector<wstring> listNames;
200                std::vector<int> listWidths;
201                std::vector<int> listOrder;
202                std::vector<bool> listVisible;
203
204                listNames.assign(listNames_.begin(), listNames_.end());
205                listWidths.assign(listWidths_.begin(), listWidths_.end());
206                listOrder.assign(listOrder_.begin(), listOrder_.end());
207                listVisible.assign(listVisible_.begin(), listVisible_.end());
208
209                TBase* pT = static_cast<TBase*>(this);
210                if (!pT->load_from_ini() || !vectorSizePreConditions())
211                {
212                        listNames_.assign(listNames.begin(), listNames.end());
213                        listWidths_.assign(listWidths.begin(), listWidths.end());
214                        listOrder_.assign(listOrder.begin(), listOrder.end());
215                        listVisible_.assign(listVisible.begin(), listVisible.end());
216                }               
217        }
218/*     
219        void ApplyDetails()
220        {
221                vectorSizePreConditions();
222               
223                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
224               
225                if (!menu_)
226                {
227                        menu_.CreatePopupMenu();
228                }
229                else
230                {                               
231                        minfo.fMask = MIIM_SUBMENU;
232                        minfo.fType = MFT_SEPARATOR;
233                       
234                        menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);           
235                }
236
237                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
238                minfo.fType = MFT_STRING;
239                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
240                minfo.wID = ID_LVM_AUTOSORT;
241               
242                wstring autoarrange = hal::app().res_wstr(HAL_AUTOSORT);
243                minfo.dwTypeData = (LPWSTR)autoarrange.c_str();
244               
245                menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);
246               
247                header_.Attach(this->GetHeader());
248                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG);
249
250                header_.Menu().CreatePopupMenu();
251
252                for (int i=header_.GetItemCount(), e=int(listNames_.size()); i<e; ++i)
253                {
254                        MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
255                        minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
256                        minfo.fType = MFT_STRING;
257                        minfo.dwTypeData = (LPWSTR)listNames_[i].c_str();
258                        minfo.wID = CHaliteHeaderCtrl::COL_MENU_NAMES+i;
259
260                        AddColumn(listNames_[i].c_str(), i);
261
262                        if (listVisible_[i])
263                        {
264                                minfo.fState = MFS_CHECKED;                     
265                                SetColumnWidth(i, listWidths_[i]);
266                        }
267                        else
268                        {
269                                minfo.fState = MFS_UNCHECKED;
270                                SetColumnWidth(i, 0);
271                        }
272
273                        header_.Menu().InsertMenuItem(header_.Menu().GetMenuItemCount(), false, &minfo);
274                }
275               
276                SetColumnOrderArray(listNames_.size(), &listOrder_[0]);
277               
278                m_bSortDescending = descending_;
279                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize())
280                        SetSortColumn(sortCol_);
281        }
282*/
283        void InitialSetup(WTL::CMenuHandle menu=WTL::CMenuHandle())
284        {
285                SetExtendedListViewStyle(LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER);
286//              SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS,SORTLV_USESHELLBITMAPS);
287
288                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
289               
290                if (!menu)
291                {
292                        menu_.CreatePopupMenu();
293                }
294                else
295                {               
296                        menu_.Attach(menu.GetSubMenu(0));
297
298                        minfo.fMask = MIIM_SUBMENU;
299                        minfo.fType = MFT_SEPARATOR;
300                       
301                        menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);           
302                }
303
304                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
305                minfo.fType = MFT_STRING;
306                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
307                minfo.wID = ID_LVM_AUTOSORT;
308               
309                std::wstring autoarrange = hal::app().res_wstr(HAL_AUTOSORT);
310                minfo.dwTypeData = (LPWSTR)autoarrange.c_str();
311               
312                menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);
313
314                header_.SubclassWindow(this->GetHeader());
315                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG);
316                if (header_.Menu().IsNull()) 
317                        header_.Menu().CreatePopupMenu();
318        }
319       
320        void GetListViewDetails()
321        {
322                vectorSizePreConditions();             
323               
324                for (size_t i=0; i<listNames_.size(); ++i)
325                {
326                        if (listVisible_[i])
327                                listWidths_[i] = GetColumnWidth(i);
328                }
329               
330                GetColumnOrderArray(listNames_.size(), &listOrder_[0]);
331               
332/*              sortCol_ = GetSortColumn();
333                descending_ = IsSortDescending();       */
334        }
335       
336        LRESULT OnAutoSort(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
337        {
338                autoSort_ = !autoSort_;
339               
340                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
341               
342                minfo.fMask = MIIM_STATE;
343                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
344               
345                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo);
346               
347                return 0;
348        }
349
350        bool OnNameChecked(int i)
351        {
352                if (!listVisible_[i])
353                {               
354                        GetColumnOrderArray(listNames_.size(), &listOrder_[0]);
355                        SetColumnWidth(i, listWidths_[i]);
356
357                        listOrder_.erase(std::find(listOrder_.begin(), listOrder_.end(), i));
358                       
359                        int index = i + std::count(listVisible_.begin()+i, listVisible_.end(), false) - 1;
360                        listOrder_.insert(listOrder_.begin()+index, i);
361
362                        SetColumnOrderArray(listNames_.size(), &listOrder_[0]);
363                        listVisible_[i] = true;
364                }
365                else
366                {
367                        listWidths_[i] = GetColumnWidth(i);     
368                        GetColumnOrderArray(listNames_.size(), &listOrder_[0]);
369
370                        SetColumnWidth(i, 0);
371
372                        listOrder_.erase(std::find(listOrder_.begin(), listOrder_.end(), i));
373                        listOrder_.insert(listOrder_.begin(), i);
374
375                        SetColumnOrderArray(listNames_.size(), &listOrder_[0]);
376                        listVisible_[i] = false;
377                }
378               
379                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};   
380                minfo.fMask = MIIM_STATE;
381                minfo.fState = listVisible_[i] ? MFS_CHECKED : MFS_UNCHECKED;   
382                header_.Menu().SetMenuItemInfo(CHaliteHeaderCtrl::COL_MENU_NAMES+i, false, &minfo);
383       
384                InvalidateRect(NULL, true);
385                return listVisible_[i];
386        }
387
388        LRESULT OnClick(int, LPNMHDR pnmh, BOOL&)
389        {
390                return 0;
391        }
392
393        LRESULT OnItemChanged(int, LPNMHDR pnmh, BOOL&)
394        {               
395                hal::try_update_lock<thisClass> lock(*this);
396               
397                if (lock) manager_.sync_list(true, true);
398               
399                return 0;
400        }
401
402        LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&)
403        {
404                LPNMITEMACTIVATE pia = (LPNMITEMACTIVATE)pnmh;
405                manager_.sync_list(true);
406               
407                if (menu_)
408                {
409                        assert (menu_.IsMenu());
410       
411                        POINT ptPoint;
412                        GetCursorPos(&ptPoint);
413                        menu_.TrackPopupMenu(0, ptPoint.x, ptPoint.y, m_hWnd);
414                }
415
416                return 0;
417        }
418
419        LRESULT OnColClick(int i, LPNMHDR pnmh, BOOL&)
420        {
421                LPNMLISTVIEW pnlv = (LPNMLISTVIEW)pnmh;
422               
423                MessageBox((lexical_cast<wstring>(pnlv->iSubItem)).c_str(), L"Hi", 0);
424                return 0;
425        }
426
427        int AddColumn(LPCTSTR strItem, int nItem, bool visible, int width=-1)
428        {
429                return AddColumn(strItem, nItem, -1,
430                        LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
431                        LVCFMT_LEFT, visible, width);
432        }
433
434        int AddColumn(LPCTSTR strItem, int nItem, int nSubItem = -1,
435                        int nMask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
436                        int nFmt = LVCFMT_LEFT, bool visible=true, int width=-1)
437        {
438
439                int i = parentClass::AddColumn(strItem, nItem, nSubItem, nMask, nFmt);
440
441                if (i == -1) return i;
442
443                if (width != -1) SetColumnWidth(i, width);
444
445                if (header_.Menu().IsNull()) 
446                        header_.Menu().CreatePopupMenu();
447
448                WTL::CMenuHandle menu = header_.Menu();
449
450                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
451                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
452                minfo.fType = MFT_STRING;
453                minfo.dwTypeData = (LPTSTR)strItem;
454                minfo.wID = CHaliteHeaderCtrl::COL_MENU_NAMES+i;
455
456                if (visible)
457                        minfo.fState = MFS_CHECKED;
458                else
459                {
460                        minfo.fState = MFS_UNCHECKED;
461                        SetColumnWidth(i, 0);
462                }
463
464                int w = GetColumnWidth(i);
465
466                listNames_.push_back(strItem);
467                listVisible_.push_back(visible);
468                listWidths_.push_back(w);
469                listOrder_.push_back(i);
470
471                menu.InsertMenuItem(menu.GetMenuItemCount(), false, &minfo);
472                return i;
473        }
474
475        void SetColumnSortType(int iCol, WORD wType, ColumnAdapter* colAdapter=NULL)
476        {
477//              parentClass::SetColumnSortType(iCol, wType);
478               
479                if (WTL::LVCOLSORT_CUSTOM == wType)
480                        regColumnAdapter(iCol, colAdapter);
481        }
482
483        void SetColumnOrderState()
484        {
485                while ((int)listOrder_.size() < header_.GetItemCount())
486                        listOrder_.push_back(header_.GetItemCount());
487
488                GetColumnOrderArray(listOrder_.size(), &listOrder_[0]);
489        }
490
491        void SetSortState()
492        {
493                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
494               
495                minfo.fMask = MIIM_STATE;
496                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
497               
498                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo);
499
500                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize())
501                        SetSortColumn(sortCol_);
502        }
503
504        friend class boost::serialization::access;
505        template<class Archive>
506    void save(Archive & ar, const unsigned int version) const
507    {
508                for (size_t i=0; i<listWidths_.size(); ++i)
509                {
510                        if (listVisible_[i])
511                                listWidths_[i] = GetColumnWidth(i);
512                }
513
514                GetColumnOrderArray(listOrder_.size(), &listOrder_[0]);
515//              sortCol_ = GetSortColumn();
516//              descending_ = IsSortDescending();       
517
518                using boost::serialization::make_nvp;
519
520                ar & make_nvp("width", listWidths_);
521                ar & make_nvp("order", listOrder_);
522                ar & make_nvp("visible", listVisible_);
523                ar & make_nvp("autoSort", autoSort_);
524
525                ar & make_nvp("descending", descending_);
526                ar & make_nvp("sortCol", sortCol_);
527    }
528
529    template<class Archive>
530    void load(Archive & ar, const unsigned int version)
531    {
532                using boost::serialization::make_nvp;
533
534                ar & make_nvp("width", listWidths_);
535                ar & make_nvp("order", listOrder_);
536                ar & make_nvp("visible", listVisible_);
537                ar & make_nvp("autoSort", autoSort_);
538
539                ar & make_nvp("descending", descending_);
540                ar & make_nvp("sortCol", sortCol_);
541               
542                SetColumnOrderArray(listOrder_.size(), &listOrder_[0]);
543
544/*              m_bSortDescending = descending_;
545                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize())
546                        SetSortColumn(sortCol_);
547*/
548                for (size_t i=0; i<listWidths_.size(); ++i)
549                {
550                        SetColumnWidth(i, listWidths_[i]);
551                        if (!listVisible_[i])
552                        {
553                                listVisible_[i] = true;
554                                OnNameChecked(i);
555                        }
556                }
557
558//              SetColumnOrderState();
559//              SetSortState();
560    }
561
562    BOOST_SERIALIZATION_SPLIT_MEMBER()
563
564        const SelectionManager& manager() { return manager_; }
565               
566        std::vector<int>& listColumnWidth() { return listColumnWidth_; }
567        std::vector<int>& listColumnOrder() { return listColumnOrder_; }
568       
569        const std::vector<int>& listColumnWidth() const { return listColumnWidth_; }
570        const std::vector<int>& listColumnOrder() const { return listColumnOrder_; }
571       
572        bool canUpdate() const { return updateLock_ == 0; }
573       
574        void clearFocused() { manager_.clear(); }
575        void clearSelected() { manager_.clear_all_selected(); }
576        void clearAll() { manager_.clear_all(); }
577       
578/*      int CompareItemsCustom(LVCompareParam* pItem1, LVCompareParam* pItem2, int iSortCol)
579        {
580                hal::mutex_update_lock<thisClass> lock(*this);
581               
582                TBase* pT = static_cast<TBase*>(this);
583               
584                AdapterType left = pT->CustomItemConversion(pItem1, iSortCol);
585                AdapterType right = pT->CustomItemConversion(pItem2, iSortCol);
586               
587                return pT->CustomItemComparision(left, right, iSortCol);
588        }
589        */
590        bool autoSort() { return autoSort_; }
591       
592        void ConditionallyDoAutoSort()
593        {
594/*              int iCol = GetSortColumn();
595                if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize())
596                        DoSortItems(iCol, IsSortDescending());  */
597        }
598               
599        ColumnAdapter* getColumnAdapter(size_t index)
600        {
601                boost::ptr_map<size_t, ColumnAdapter>::iterator
602                        i = columnAdapters_.find(index);
603       
604                if (i != columnAdapters_.end())
605                {
606                        return i->second;
607                }               
608                return NULL;
609        }
610
611        static bool is_selected (const winstl::listview_sequence::sequence_value_type& v) 
612        { 
613                return (v.state() & LVIS_SELECTED) != 0; 
614        }
615
616protected:     
617/*      inline void* CustomItemConversion(LVCompareParam* param, int iSortCol)
618        {
619                assert(false);
620                return NULL;
621        }
622       
623        int CustomItemComparision(AdapterType left, AdapterType right, int iSortCol)
624        {
625                ColumnAdapter* pCA = getColumnAdapter(iSortCol);
626               
627                if (pCA)
628                        return pCA->compare(left, right);
629                else
630                        return 0;
631        }
632        */
633        void regColumnAdapter(size_t key, ColumnAdapter* colAdapter)
634        {
635                assert (colAdapter);
636                columnAdapters_.insert(key, colAdapter);
637        }
638
639//      AdapterType convert(const LPLVITEM item);
640//      void convert(LPLVITEM item, AdapterType adapter);
641       
642        SelectionManager manager_;
643        WTL::CMenu menu_;
644        CHaliteHeaderCtrl header_;     
645       
646private:
647        bool vectorSizePreConditions()
648        {
649                bool ret = (listNames_.size() == listWidths_.size()) &&
650                        (listNames_.size() == listOrder_.size()) &&
651                        (listNames_.size() == listVisible_.size());
652
653                return ret;
654        }       
655       
656        mutable std::vector<wstring> listNames_;
657        mutable std::vector<int> listWidths_;
658        mutable std::vector<int> listOrder_;
659        mutable std::vector<bool> listVisible_;
660        mutable bool autoSort_;
661        mutable bool descending_;
662        mutable int sortCol_;
663       
664        mutable int update_lock_;
665        mutable hal::mutex_t mutex_;
666
667        friend class hal::mutex_update_lock<thisClass>; 
668        friend class hal::try_update_lock<thisClass>;           
669       
670        boost::ptr_map<size_t, ColumnAdapter> columnAdapters_;
671       
672        WinAPIWaitableTimer syncTimer_;
673};
674
675template<>
676inline const std::wstring hal::to_wstr_shim<const winstl::listview_sequence::sequence_value_type>
677        (const winstl::listview_sequence::sequence_value_type& v)
678{
679        return std::wstring(winstl::c_str_ptr(v));
680}
681
682namespace boost {
683namespace serialization {
684        template <class TBase, typename AdapterType>
685        struct version< CHaliteSortListViewCtrl<TBase, AdapterType> >
686        {
687                typedef mpl::int_<2> type;
688                typedef mpl::integral_c_tag tag;
689                BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);                                                             
690        };
691}
692}
Note: See TracBrowser for help on using the repository browser.