source: trunk/src/HaliteSortListViewCtrl.hpp @ 519

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

Adding a 'queued view' mode to main listview.

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