source: trunk/src/HaliteSortListViewCtrl.hpp @ 392

Revision 392, 19.0 KB checked in by Eoin, 12 years ago (diff)

Tweaked for precompiled headers.

Line 
1
2//         Copyright Eóin O'Callaghan 2006 - 2007.
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#include <boost/array.hpp>
13#include <boost/signals.hpp>
14#include <boost/algorithm/string/split.hpp>
15#include <boost/serialization/vector.hpp>
16#include <boost/serialization/split_free.hpp>
17#include <boost/ptr_container/ptr_map.hpp>
18
19#include "Halite.hpp"
20#include "halTorrent.hpp"
21#include "halEvent.hpp"
22#include "WinAPIWaitableTimer.hpp"
23
24#include "UxthemeWrapper.hpp"
25
26#define LVS_EX_DOUBLEBUFFER     0x00010000
27
28#include "HaliteUpdateLock.hpp"
29
30namespace hal
31{
32
33template<typename T>
34int compare(const T& l, const T& r)
35{
36        if (l == r) 
37                return 0;
38        else if (l > r) 
39                return 1;
40        else 
41                return -1;
42}
43
44}
45
46template <class TBase, typename adapterType=void*, size_t N=-1>
47class CHaliteSortListViewCtrl : 
48        public WTL::CSortListViewCtrlImpl<CHaliteSortListViewCtrl<TBase, adapterType, N> >
49{
50public:
51        typedef CHaliteSortListViewCtrl<TBase, adapterType, N> thisClass;
52        typedef CSortListViewCtrlImpl<thisClass> parentClass;
53       
54        class selection_manager : 
55                private boost::noncopyable
56        {       
57        public:
58                selection_manager(thisClass& m_list) :
59                        m_list_(m_list)
60                {}
61               
62                typedef std::wstring string_t; 
63                typedef const string_t& param_type;
64               
65                void sync_list(bool list_to_manager, bool signal_change=true)
66                {
67                        if (list_to_manager)
68                        {       
69                                if (listToManager() && signal_change) signal();
70                        }
71                        else
72                        {
73                                if (managerToList() && signal_change) signal();
74                        }
75                }
76               
77                bool listToManager()
78                {
79                        boost::array<wchar_t, MAX_PATH> pathBuffer;
80                        std::set<string_t> all_selected;
81                        string_t selected = L"";
82                       
83                        bool do_signal = false;
84                       
85                        int total = m_list_.GetItemCount();
86                       
87                        for (int i=0; i<total; ++i)
88                        {
89                                UINT flags = m_list_.GetItemState(i, LVIS_SELECTED);
90                               
91                                if (flags && LVIS_SELECTED)
92                                {
93                                        m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size());     
94                                        all_selected.insert(pathBuffer.data());
95                                }
96                                if (flags && LVIS_FOCUSED)
97                                {
98                                        selected = pathBuffer.data();
99                                }
100                        }
101
102                        if (all_selected != all_selected_)
103                        {
104                                std::swap(all_selected_, all_selected);
105                                do_signal = true;
106                        }
107                                       
108                        if (selected_ != selected)
109                        {
110                                std::swap(selected_, selected);
111                                do_signal = true;
112                        }
113                       
114                        return do_signal;
115                }
116               
117                bool managerToList()
118                {
119                        // Prevent changing states from signaling another sync
120                        UpdateLock<thisClass> lock(m_list_);
121                       
122                        boost::array<wchar_t, MAX_PATH> pathBuffer;
123                        LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) }; 
124                        findInfo.flags = LVFI_STRING;
125                       
126                        bool do_signal = true; // Always signal for now!
127                       
128                        int total = m_list_.GetItemCount();
129                       
130                        for (int i=0; i<total; ++i)
131                        {
132                                m_list_.GetItemText(i, 0, pathBuffer.c_array(), pathBuffer.size());
133                                string_t temp_name = pathBuffer.data();
134                               
135                                LVITEM lvi = { LVIF_STATE };
136                                lvi.state = 0;
137                                lvi.stateMask = LVIS_SELECTED|LVIS_FOCUSED;
138                               
139                                if (temp_name == selected_)
140                                {
141                                        lvi.state |= LVIS_FOCUSED;
142                                }
143                                if (all_selected_.find(temp_name) != all_selected_.end())
144                                {
145                                        lvi.state |= LVIS_SELECTED;
146                                }
147                               
148                                m_list_.SetItemState(i, &lvi);
149                        }                       
150                       
151                        return do_signal;
152                }
153               
154                int selectMatch(const string_t& name)
155                {
156                        LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) }; 
157                        findInfo.flags = LVFI_STRING;
158                                       
159                        findInfo.psz = name.c_str();
160                       
161                        int itemPos = m_list_.FindItem(&findInfo, -1); 
162                                               
163                        if (itemPos == -1)
164                                return itemPos;
165                               
166                        UINT flags = m_list_.GetItemState(itemPos, LVIS_SELECTED);
167                       
168                        //if (!flags && LVIS_SELECTED)
169                        {
170                                LVITEM lvi = { LVIF_STATE };
171                                lvi.state = LVIS_SELECTED;
172                                lvi.stateMask = LVIS_SELECTED;
173                                m_list_.SetItemState(itemPos, &lvi);
174                        }
175               
176                        return itemPos;
177                }
178               
179                param_type selected() const { return selected_; }
180               
181                int selectedIndex() const
182                {
183                        LV_FINDINFO findInfo = { sizeof(LV_FINDINFO) };         
184                        findInfo.psz = selected_.c_str();
185                       
186                        return m_list_.FindItem(&findInfo, -1);         
187                }
188               
189                const std::set<string_t>& allSelected() const { return all_selected_; }
190               
191                void setSelected(const string_t& sel) 
192                {
193                        selected_ = sel;
194                }
195               
196                void setSelected(int itemPos)
197                {               
198                        hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"Set Selected %1%") % itemPos).str().c_str())));
199
200                        LVITEM lvi = { LVIF_STATE };
201                        lvi.state = LVIS_SELECTED|LVIS_FOCUSED;
202                        lvi.stateMask = LVIS_SELECTED|LVIS_FOCUSED;
203                        m_list_.SetItemState(itemPos, &lvi);
204                       
205                        m_list_.SetSelectionMark(itemPos);
206                       
207                        sync_list(true);
208                }
209               
210                void clear()
211                {
212                        // Prevent changing states from signaling another sync
213                        UpdateLock<thisClass> lock(m_list_);
214                       
215                        m_list_.DeleteItem(selectedIndex());
216                       
217                        sync_list(true);       
218                }
219               
220                void clear_all_selected()
221                {
222                        // Prevent changing states from signaling another sync
223                        UpdateLock<thisClass> lock(m_list_);
224                       
225                        int total = m_list_.GetItemCount();
226                       
227                        for (int i=total-1; i>=0; --i)
228                        {
229                                UINT flags = m_list_.GetItemState(i, LVIS_SELECTED);
230                               
231                                if (flags && LVIS_SELECTED)
232                                        m_list_.DeleteItem(i);
233                        }
234                        all_selected_.clear();
235                       
236                        sync_list(true);       
237                }
238               
239                void clear_all()
240                {
241                        // Prevent changing states from signaling another sync
242                        UpdateLock<thisClass> lock(m_list_);
243                       
244                        m_list_.DeleteAllItems();
245                        all_selected_.clear();
246                       
247                        sync_list(true);               
248                }
249               
250                void attach(boost::function<void (param_type)> fn) const { selection_.connect(fn); }
251               
252                void signal() 
253                { 
254                        selection_(selected_); 
255                }
256               
257        private:
258                string_t selected_;
259                std::set<string_t> all_selected_;
260               
261                mutable boost::signal<void (param_type)> selection_;
262                thisClass& m_list_;
263        };
264       
265        class CHaliteHeaderCtrl : public CWindowImpl<CHaliteHeaderCtrl, WTL::CHeaderCtrl>
266        {
267        public:
268                enum { COL_MENU_NAMES = 123, COL_MAX_NAMES = 256};
269
270                CHaliteHeaderCtrl(thisClass& listView) :
271                        listView_(listView)
272                {}
273
274                BEGIN_MSG_MAP(CHaliteHeaderCtrl)
275                        REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick)
276                        COMMAND_RANGE_HANDLER(COL_MENU_NAMES, COL_MENU_NAMES+COL_MAX_NAMES, OnMenuNames)
277
278                        DEFAULT_REFLECTION_HANDLER()
279                END_MSG_MAP()
280               
281                void Attach(HWND hWndNew)
282                {
283                        ATLASSERT(::IsWindow(hWndNew));
284                        CWindowImpl<CHaliteHeaderCtrl, CHeaderCtrl>::SubclassWindow(hWndNew);
285                }
286               
287                LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&)
288                {
289                        POINT ptPoint;
290                        GetCursorPos(&ptPoint);
291                        menu_.TrackPopupMenu(0, ptPoint.x, ptPoint.y, m_hWnd);
292
293                        return 0;
294                }
295
296                LRESULT OnMenuNames(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
297                {               
298                        ATLASSERT(wID-COL_MENU_NAMES <= GetItemCount());
299
300                        bool visible = listView_.OnNameChecked(wID-COL_MENU_NAMES);
301
302                        MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
303               
304                        minfo.fMask = MIIM_STATE;
305                        minfo.fState = visible ? MFS_CHECKED : MFS_UNCHECKED;
306               
307                        menu_.SetMenuItemInfo(wID, false, &minfo);
308
309                        return 0;
310                }
311
312                WTL::CMenu& Menu()
313                {
314                        return menu_;
315                }
316               
317        private:
318                WTL::CMenu menu_;
319                thisClass& listView_;
320        };
321       
322        struct ColumnAdapter
323        {
324                virtual int compare(adapterType& l, adapterType& r) = 0;
325                virtual std::wstring print(adapterType& t) = 0;
326        };
327
328public:
329        typedef selection_manager SelectionManager;
330        typedef SelectionManager selection_manage_class;
331       
332        thisClass(bool resMenu=true, bool resNames=true, bool resWidthsAndOrder=true) :
333                manager_(*this),
334                header_(*this),
335                updateLock_(0),
336                autoSort_(false),
337                descending_(false),
338                sortCol_(-1)
339        {               
340                if (resMenu && TBase::LISTVIEW_ID_MENU)
341                {
342                        CMenuHandle menu;
343                        BOOL menu_created = menu.LoadMenu(TBase::LISTVIEW_ID_MENU);
344                        assert(menu_created);   
345                       
346                        menu_.Attach(menu.GetSubMenu(0));
347                }
348
349                if (resNames)
350                {
351                        wstring column_names = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNNAMES);
352                        boost::split(listNames_, column_names, boost::is_any_of(L";"));
353                }
354               
355                if (resWidthsAndOrder)
356                {
357                        wstring column_widths = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNWIDTHS);
358                        std::vector<wstring> widths;
359                        boost::split(widths, column_widths, boost::is_any_of(L";"));
360                       
361                        listWidths_.reserve(listNames_.size()); 
362                        listOrder_.reserve(listNames_.size());
363                       
364                        for (size_t i=0; i<listNames_.size(); ++i)
365                        {
366                                listWidths_.push_back(lexical_cast<int>(widths[i]));
367                                listOrder_.push_back(i);
368                        }
369                }
370        }
371
372        BEGIN_MSG_MAP_EX(thisClass)
373                COMMAND_ID_HANDLER(ID_LVM_AUTOSORT, OnAutoSort)
374               
375                REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick)
376                REFLECTED_NOTIFY_CODE_HANDLER(LVN_ITEMCHANGED, OnItemChanged)
377
378                DEFAULT_REFLECTION_HANDLER()
379                CHAIN_MSG_MAP(parentClass)
380        END_MSG_MAP()
381
382        void Attach(HWND hWndNew)
383        {
384                ATLASSERT(::IsWindow(hWndNew));
385        parentClass::SubclassWindow(hWndNew);
386
387                TBase* pT = static_cast<TBase*>(this);
388                pT->OnAttach();
389        }
390       
391        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
392                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
393                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
394        {
395                HWND hwnd = parentClass::Create(hWndParent, 
396                        (RECT &)rect.m_lpRect, szWindowName, dwStyle, dwExStyle, (UINT)MenuOrID.m_hMenu, lpCreateParam);
397                       
398                SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER);
399                SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS);
400               
401                return hwnd;
402        }
403       
404        bool SubclassWindow(HWND hwnd)
405        {
406                if(!parentClass::SubclassWindow(hwnd))
407                        return false;
408                       
409                SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER);
410                SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS);
411               
412                return true;
413        }               
414       
415        void SetListViewDetails()
416        {
417                vectorSizePreConditions();
418               
419                header_.Attach(this->GetHeader());
420                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG);
421                       
422                foreach (wstring name, listNames_)
423                {
424                        int i = header_.GetItemCount();
425                       
426                        AddColumn(name.c_str(), i);
427                }               
428
429                for (unsigned i=0; i<listNames_.size(); ++i)
430                        SetColumnWidth(i, listOrder_[i]);
431               
432                SetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
433        }
434       
435        template<typename N, typename W, typename O, typename P>
436        void SetDefaults(N nameList, W widthList, O orderList, P visibleList, bool autoSort=false)
437        {
438                listNames_.assign(nameList.begin(), nameList.end());
439                listWidths_.assign(widthList.begin(), widthList.end());
440                listOrder_.assign(orderList.begin(), orderList.end());
441                listVisible_.assign(visibleList.begin(), visibleList.end());
442               
443                autoSort_ = autoSort;
444        }
445       
446        template<std::size_t Size>
447        void SetDefaults(array<int, Size> a)
448        {
449                assert (Size == listNames_.size());
450                vectorSizePreConditions();
451               
452                for (size_t i=0; i<listNames_.size(); ++i)
453                {
454                        listWidths_[i] = a[i];
455                        listOrder_[i] = i;
456                }               
457        }
458       
459        void ApplyDetails()
460        {
461                vectorSizePreConditions();
462               
463                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
464               
465                if (!menu_)
466                {
467                        menu_.CreatePopupMenu();
468                }
469                else
470                {                               
471                        minfo.fMask = MIIM_SUBMENU;
472                        minfo.fType = MFT_SEPARATOR;
473                       
474                        menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);           
475                }
476
477                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
478                minfo.fType = MFT_STRING;
479                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
480                minfo.wID = ID_LVM_AUTOSORT;
481               
482                wstring autoarrange = hal::app().res_wstr(HAL_AUTOSORT);
483                minfo.dwTypeData = (LPWSTR)autoarrange.c_str();
484               
485                menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);
486               
487                header_.Attach(this->GetHeader());
488                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG);
489
490                header_.Menu().CreatePopupMenu();
491
492                for (int i=header_.GetItemCount(), e=int(listNames_.size()); i<e; ++i)
493                {
494                        MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
495                        minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE;
496                        minfo.fType = MFT_STRING;
497                        minfo.dwTypeData = (LPWSTR)listNames_[i].c_str();
498                        minfo.wID = CHaliteHeaderCtrl::COL_MENU_NAMES+i;
499
500                        AddColumn(listNames_[i].c_str(), i);
501
502                        if (listVisible_[i])
503                        {
504                                minfo.fState = MFS_CHECKED;                     
505                                SetColumnWidth(i, listWidths_[i]);
506                        }
507                        else
508                        {
509                                minfo.fState = MFS_UNCHECKED;
510                                SetColumnWidth(i, 0);
511                        }
512
513                        header_.Menu().InsertMenuItem(header_.Menu().GetMenuItemCount(), false, &minfo);
514                }
515               
516                SetColumnOrderArray(listNames_.size(), &listOrder_[0]);
517               
518                m_bSortDescending = descending_;
519                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize())
520                        SetSortColumn(sortCol_);
521        }
522       
523        void GetListViewDetails()
524        {
525                vectorSizePreConditions();             
526               
527                for (size_t i=0; i<listNames_.size(); ++i)
528                {
529                        if (listVisible_[i])
530                                listWidths_[i] = GetColumnWidth(i);
531                }
532               
533                GetColumnOrderArray(listNames_.size(), &listOrder_[0]);
534               
535                sortCol_ = GetSortColumn();
536                descending_ = IsSortDescending();       
537        }
538       
539        LRESULT OnAutoSort(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
540        {
541                autoSort_ = !autoSort_;
542               
543                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};
544               
545                minfo.fMask = MIIM_STATE;
546                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED;
547               
548                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo);
549               
550                return 0;
551        }
552
553        bool OnNameChecked(int i)
554        {
555                if (!listVisible_[i])
556                {               
557                        GetColumnOrderArray(listNames_.size(), &listOrder_[0]);
558                        SetColumnWidth(i, listWidths_[i]);
559
560                        listOrder_.erase(std::find(listOrder_.begin(), listOrder_.end(), i));
561                       
562                        int index = i + std::count(listVisible_.begin()+i, listVisible_.end(), false) - 1;
563                        listOrder_.insert(listOrder_.begin()+index, i);
564
565                        SetColumnOrderArray(listNames_.size(), &listOrder_[0]);
566                        listVisible_[i] = true;
567                }
568                else
569                {
570                        listWidths_[i] = GetColumnWidth(i);     
571                        GetColumnOrderArray(listNames_.size(), &listOrder_[0]);
572
573                        SetColumnWidth(i, 0);
574
575                        listOrder_.erase(std::find(listOrder_.begin(), listOrder_.end(), i));
576                        listOrder_.insert(listOrder_.begin(), i);
577
578                        SetColumnOrderArray(listNames_.size(), &listOrder_[0]);
579                        listVisible_[i] = false;
580                }
581       
582                InvalidateRect(NULL, true);
583                return listVisible_[i];
584        }
585
586        LRESULT OnClick(int, LPNMHDR pnmh, BOOL&)
587        {
588                return 0;
589        }
590
591        LRESULT OnItemChanged(int, LPNMHDR pnmh, BOOL&)
592        {               
593                TryUpdateLock<thisClass> lock(*this);
594                if (lock) 
595                        manager_.sync_list(true, true);
596                        //syncTimer_.reset(50, 0, bind(&thisClass::syncTimeout, this));
597               
598                return 0;
599        }
600
601        LRESULT OnRClick(int i, LPNMHDR pnmh, BOOL&)
602        {
603                LPNMITEMACTIVATE pia = (LPNMITEMACTIVATE)pnmh;
604                manager_.sync_list(true);
605               
606                if (menu_)
607                {
608                        assert (menu_.IsMenu());
609       
610                        POINT ptPoint;
611                        GetCursorPos(&ptPoint);
612                        menu_.TrackPopupMenu(0, ptPoint.x, ptPoint.y, m_hWnd);
613                }
614
615                return 0;
616        }
617
618        LRESULT OnColClick(int i, LPNMHDR pnmh, BOOL&)
619        {
620                LPNMLISTVIEW pnlv = (LPNMLISTVIEW)pnmh;
621               
622                MessageBox((lexical_cast<wstring>(pnlv->iSubItem)).c_str(), L"Hi", 0);
623                return 0;
624        }
625       
626        void SetColumnSortType(int iCol, WORD wType, ColumnAdapter* colAdapter=NULL)
627        {
628                parentClass::SetColumnSortType(iCol, wType);
629               
630                if (LVCOLSORT_CUSTOM == wType)
631                        regColumnAdapter(iCol, colAdapter);
632        }
633       
634        friend class boost::serialization::access;
635    template<class Archive>
636    void serialize(Archive & ar, const unsigned int version)
637    {
638                if (version >= 1)
639                {
640                        ar & boost::serialization::make_nvp("width", listWidths_);
641                        ar & boost::serialization::make_nvp("order", listOrder_);
642                        ar & boost::serialization::make_nvp("visible", listVisible_);
643                        ar & boost::serialization::make_nvp("autoSort", autoSort_);
644                }
645                if (version >= 2)
646                {
647                        ar & boost::serialization::make_nvp("descending", descending_);
648                        ar & boost::serialization::make_nvp("sortCol", sortCol_);
649                }
650    }
651
652        const SelectionManager& manager() { return manager_; }
653               
654        std::vector<int>& listColumnWidth() { return listColumnWidth_; }
655        std::vector<int>& listColumnOrder() { return listColumnOrder_; }
656       
657        const std::vector<int>& listColumnWidth() const { return listColumnWidth_; }
658        const std::vector<int>& listColumnOrder() const { return listColumnOrder_; }
659       
660        bool canUpdate() const { return updateLock_ == 0; }
661       
662        void clearFocused() { manager_.clear(); }
663        void clearSelected() { manager_.clear_all_selected(); }
664        void clearAll() { manager_.clear_all(); }
665       
666        int CompareItemsCustom(LVCompareParam* pItem1, LVCompareParam* pItem2, int iSortCol)
667        {
668                UpdateLock<thisClass> lock(*this);
669               
670                TBase* pT = static_cast<TBase*>(this);
671               
672                adapterType left = pT->CustomItemConversion(pItem1, iSortCol);
673                adapterType right = pT->CustomItemConversion(pItem2, iSortCol);
674               
675                return pT->CustomItemComparision(left, right, iSortCol);
676        }
677       
678        bool autoSort() { return autoSort_; }
679       
680        void ConditionallyDoAutoSort()
681        {
682                int iCol = GetSortColumn();
683                if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize())
684                        DoSortItems(iCol, IsSortDescending()); 
685        }
686               
687        ColumnAdapter* getColumnAdapter(size_t index)
688        {
689                boost::ptr_map<size_t, ColumnAdapter>::iterator
690                        i = columnAdapters_.find(index);
691       
692                if (i != columnAdapters_.end())
693                {
694                        return i->second;
695                }               
696                return NULL;
697        }
698       
699protected:     
700        inline void* CustomItemConversion(LVCompareParam* param, int iSortCol)
701        {
702                assert(false);
703                return NULL;
704        }
705       
706        int CustomItemComparision(adapterType left, adapterType right, int iSortCol)
707        {
708                ColumnAdapter* pCA = getColumnAdapter(iSortCol);
709               
710                if (pCA)
711                        return pCA->compare(left, right);
712                else 
713                        return 0;
714        }
715       
716        void regColumnAdapter(size_t key, ColumnAdapter* colAdapter)
717        {
718                assert (colAdapter);
719                columnAdapters_.insert(key, colAdapter);
720        }
721       
722        SelectionManager manager_;
723       
724private:
725        void vectorSizePreConditions()
726        {
727/*              if (listColumnWidth_.size() != names_.size())
728                {
729                        listColumnWidth_.clear();
730                        listColumnWidth_.insert(listColumnWidth_.end(), names_.size(), 50);     
731                }
732               
733                if (listColumnOrder_.size() != names_.size())
734                {               
735                        listColumnOrder_.clear();
736                        listColumnOrder_.insert(listColumnOrder_.end(), names_.size(), 0);
737                }
738*/
739        }
740       
741        void syncTimeout()
742        {
743        //      hal::event().post(shared_ptr<hal::EventDetail>
744        //              (new hal::EventDebug(hal::Event::info, (wformat(L"Signaled")).str().c_str())));
745               
746                manager_.sync_list(true, true);
747        }
748       
749        WTL::CMenu menu_;
750        CHaliteHeaderCtrl header_;     
751       
752        std::vector<wstring> listNames_;
753        std::vector<int> listWidths_;
754        std::vector<int> listOrder_;
755        std::vector<bool> listVisible_;
756        bool autoSort_;
757        bool descending_;
758        int sortCol_;
759       
760        int updateLock_;
761        friend class UpdateLock<thisClass>;     
762        friend class TryUpdateLock<thisClass>;         
763       
764        boost::ptr_map<size_t, ColumnAdapter> columnAdapters_;
765       
766        WinAPIWaitableTimer syncTimer_;
767};
768
769namespace boost {
770namespace serialization {
771template <class TBase, typename adapterType, size_t N>
772struct version< CHaliteSortListViewCtrl<TBase, adapterType, N> >
773{
774    typedef mpl::int_<2> type;
775    typedef mpl::integral_c_tag tag;
776    BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);                                                             
777};
778}
779}
Note: See TracBrowser for help on using the repository browser.