source: trunk/src/HaliteSortListViewCtrl.hpp @ 655

Revision 655, 18.3 KB checked in by Eoin, 11 years ago (diff)

SortList? mixin coded.

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