source: trunk/src/HaliteSortListViewCtrl.hpp @ 656

Revision 656, 18.5 KB checked in by Eoin, 11 years ago (diff)

Halite ListView? sorting fully working. Clean up to follow.

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 OnSortChanged(int, LPNMHDR pnmh, BOOL&)
406        {               
407                hal::try_update_lock<thisClass> lock(*this);
408               
409                if (lock) manager_.sync_list(true, true);
410               
411                return 0;
412        }
413*/
414        LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&)
415        {
416                LPNMITEMACTIVATE pia = (LPNMITEMACTIVATE)pnmh;
417                manager_.sync_list(true);
418               
419                if (menu_)
420                {
421                        assert (menu_.IsMenu());
422       
423                        POINT ptPoint;
424                        GetCursorPos(&ptPoint);
425                        menu_.TrackPopupMenu(0, ptPoint.x, ptPoint.y, m_hWnd);
426                }
427
428                return 0;
429        }
430
431        LRESULT OnColClick(int i, LPNMHDR pnmh, BOOL&)
432        {
433                LPNMLISTVIEW pnlv = (LPNMLISTVIEW)pnmh;
434               
435                MessageBox((lexical_cast<wstring>(pnlv->iSubItem)).c_str(), L"Hi", 0);
436                return 0;
437        }
438
439        void SortByColumn(size_t column_index)
440        {
441                /* Overwriteable */
442        }
443
444        bool DoSortItems(int iCol, bool bDescending = false)
445        {
446                return true;
447        }
448
449        int AddColumn(LPCTSTR strItem, int nItem, bool visible, int width=-1)
450        {
451                return AddColumn(strItem, nItem, -1,
452                        LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
453                        LVCFMT_LEFT, visible, width);
454        }
455
456        int AddColumn(LPCTSTR strItem, int nItem, int nSubItem = -1,
457                        int nMask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
458                        int nFmt = LVCFMT_LEFT, bool visible=true, int width=-1)
459        {
460                int i = parentClass::AddColumn(strItem, nItem, nSubItem, nMask, nFmt);
461
462                if (i == -1) return i;
463
464                if (width != -1) SetColumnWidth(i, width);
465
466                if (header_.Menu().IsNull()) 
467                        header_.Menu().CreatePopupMenu();
468
469                WTL::CMenuHandle menu = header_.Menu();
470
471                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
472                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
473                minfo.fType = MFT_STRING;
474                minfo.dwTypeData = (LPTSTR)strItem;
475                minfo.wID = CHaliteHeaderCtrl::COL_MENU_NAMES+i;
476
477                if (visible)
478                        minfo.fState = MFS_CHECKED;
479                else
480                {
481                        minfo.fState = MFS_UNCHECKED;
482                        SetColumnWidth(i, 0);
483                }
484
485                int w = GetColumnWidth(i);
486
487                listNames_.push_back(strItem);
488                listVisible_.push_back(visible);
489                listWidths_.push_back(w);
490                listOrder_.push_back(i);
491
492                menu.InsertMenuItem(menu.GetMenuItemCount(), false, &minfo);
493                return i;
494        }
495
496        void SetColumnSortType(int iCol, WORD wType, ColumnAdapter* colAdapter=NULL)
497        {
498                listClass::SetColumnSortType(iCol, wType);
499               
500                if (WTL::LVCOLSORT_CUSTOM == wType)
501                        regColumnAdapter(iCol, colAdapter);
502        }
503
504        void SetColumnOrderState()
505        {
506                while ((int)listOrder_.size() < header_.GetItemCount())
507                        listOrder_.push_back(header_.GetItemCount());
508
509                GetColumnOrderArray(listOrder_.size(), &listOrder_[0]);
510        }
511
512        void SetSortState()
513        {
514                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
515               
516                minfo.fMask = MIIM_STATE;
517                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
518               
519                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo);
520
521                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize())
522                        SetSortColumn(sortCol_);
523        }
524
525        friend class boost::serialization::access;
526        template<class Archive>
527    void save(Archive & ar, const unsigned int version) const
528    {
529                for (size_t i=0; i<listWidths_.size(); ++i)
530                {
531                        if (listVisible_[i])
532                                listWidths_[i] = GetColumnWidth(i);
533                }
534
535                GetColumnOrderArray(listOrder_.size(), &listOrder_[0]);
536//              sortCol_ = GetSortColumn();
537//              descending_ = IsSortDescending();       
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
550    template<class Archive>
551    void load(Archive & ar, const unsigned int version)
552    {
553                using boost::serialization::make_nvp;
554
555                ar & make_nvp("width", listWidths_);
556                ar & make_nvp("order", listOrder_);
557                ar & make_nvp("visible", listVisible_);
558                ar & make_nvp("autoSort", autoSort_);
559
560                ar & make_nvp("descending", descending_);
561                ar & make_nvp("sortCol", sortCol_);
562               
563                SetColumnOrderArray(listOrder_.size(), &listOrder_[0]);
564
565/*              m_bSortDescending = descending_;
566                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize())
567                        SetSortColumn(sortCol_);
568*/
569                for (size_t i=0; i<listWidths_.size(); ++i)
570                {
571                        SetColumnWidth(i, listWidths_[i]);
572                        if (!listVisible_[i])
573                        {
574                                listVisible_[i] = true;
575                                OnNameChecked(i);
576                        }
577                }
578
579//              SetColumnOrderState();
580//              SetSortState();
581    }
582
583    BOOST_SERIALIZATION_SPLIT_MEMBER()
584
585        const SelectionManager& manager() { return manager_; }
586               
587        std::vector<int>& listColumnWidth() { return listColumnWidth_; }
588        std::vector<int>& listColumnOrder() { return listColumnOrder_; }
589       
590        const std::vector<int>& listColumnWidth() const { return listColumnWidth_; }
591        const std::vector<int>& listColumnOrder() const { return listColumnOrder_; }
592       
593        bool canUpdate() const { return updateLock_ == 0; }
594       
595        void clearFocused() { manager_.clear(); }
596        void clearSelected() { manager_.clear_all_selected(); }
597        void clearAll() { manager_.clear_all(); }
598       
599/*      int CompareItemsCustom(LVCompareParam* pItem1, LVCompareParam* pItem2, int iSortCol)
600        {
601                hal::mutex_update_lock<thisClass> lock(*this);
602               
603                TBase* pT = static_cast<TBase*>(this);
604               
605                AdapterType left = pT->CustomItemConversion(pItem1, iSortCol);
606                AdapterType right = pT->CustomItemConversion(pItem2, iSortCol);
607               
608                return pT->CustomItemComparision(left, right, iSortCol);
609        }
610        */
611        bool autoSort() { return autoSort_; }
612       
613        void ConditionallyDoAutoSort()
614        {
615/*              int iCol = GetSortColumn();
616                if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize())
617                        DoSortItems(iCol, IsSortDescending());  */
618        }
619               
620        ColumnAdapter* getColumnAdapter(size_t index)
621        {
622                boost::ptr_map<size_t, ColumnAdapter>::iterator
623                        i = columnAdapters_.find(index);
624       
625                if (i != columnAdapters_.end())
626                {
627                        return i->second;
628                }               
629                return NULL;
630        }
631
632        static bool is_selected (const winstl::listview_sequence::sequence_value_type& v) 
633        { 
634                return (v.state() & LVIS_SELECTED) != 0; 
635        }
636
637protected:     
638/*      inline void* CustomItemConversion(LVCompareParam* param, int iSortCol)
639        {
640                assert(false);
641                return NULL;
642        }
643       
644        int CustomItemComparision(AdapterType left, AdapterType right, int iSortCol)
645        {
646                ColumnAdapter* pCA = getColumnAdapter(iSortCol);
647               
648                if (pCA)
649                        return pCA->compare(left, right);
650                else
651                        return 0;
652        }
653        */
654        void regColumnAdapter(size_t key, ColumnAdapter* colAdapter)
655        {
656                assert (colAdapter);
657                columnAdapters_.insert(key, colAdapter);
658        }
659
660//      AdapterType convert(const LPLVITEM item);
661//      void convert(LPLVITEM item, AdapterType adapter);
662       
663        SelectionManager manager_;
664        WTL::CMenu menu_;
665        CHaliteHeaderCtrl header_;     
666       
667private:
668        bool vectorSizePreConditions()
669        {
670                bool ret = (listNames_.size() == listWidths_.size()) &&
671                        (listNames_.size() == listOrder_.size()) &&
672                        (listNames_.size() == listVisible_.size());
673
674                return ret;
675        }       
676       
677        mutable std::vector<wstring> listNames_;
678        mutable std::vector<int> listWidths_;
679        mutable std::vector<int> listOrder_;
680        mutable std::vector<bool> listVisible_;
681        mutable bool autoSort_;
682        mutable bool descending_;
683        mutable int sortCol_;
684       
685        mutable int update_lock_;
686        mutable hal::mutex_t mutex_;
687
688        friend class hal::mutex_update_lock<thisClass>; 
689        friend class hal::try_update_lock<thisClass>;           
690       
691        boost::ptr_map<size_t, ColumnAdapter> columnAdapters_;
692       
693        WinAPIWaitableTimer syncTimer_;
694};
695
696template<>
697inline const std::wstring hal::to_wstr_shim<const winstl::listview_sequence::sequence_value_type>
698        (const winstl::listview_sequence::sequence_value_type& v)
699{
700        return std::wstring(winstl::c_str_ptr(v));
701}
702
703namespace boost {
704namespace serialization {
705        template <class TBase, typename AdapterType>
706        struct version< CHaliteSortListViewCtrl<TBase, AdapterType> >
707        {
708                typedef mpl::int_<2> type;
709                typedef mpl::integral_c_tag tag;
710                BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);                                                             
711        };
712}
713}
Note: See TracBrowser for help on using the repository browser.