Changeset 715


Ignore:
Timestamp:
02/05/09 15:29:15 (10 years ago)
Author:
Eoin
Message:
 
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branch_0_3_1/src/Halite.cpp

    r573 r715  
    99#define HALITE_GUID L"HALITE-{E3A8BF7D-962F-476E-886B-FECEDD2F0FC7}" 
    1010#define WMU_ARE_YOU_ME_STRING  L"WMU_ARE_YOU_ME_HALITE-{E3A8BF7D-962F-476E-886B-FECEDD2F0FC7}" 
    11 #pragma comment(linker, "\"/manifestdependency:type='Win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") 
     11#pragma comment(linker, "\"/manifestdependency:type='Win32' \ 
     12        name='Microsoft.Windows.Common-Controls' \ 
     13        version='6.0.0.0' \ 
     14        processorArchitecture='*' \ 
     15        publicKeyToken='6595b64144ccf1df' \ 
     16        language='*'\"") 
    1217 
    1318#include "Halite.hpp" 
  • trunk/src/HaliteDialog.cpp

    r710 r715  
    203203                        SetItemText(itemPos, 1, (*i).country.c_str()); 
    204204                         
    205                         SetItemText(itemPos, 2, getColumnAdapter(2)->print(*i).c_str()); 
    206                          
    207                         SetItemText(itemPos, 3, getColumnAdapter(3)->print(*i).c_str()); 
     205                        SetItemText(itemPos, 2, (hal::wform(L"%1$.2fkb/s") % ((*i).speed.first/1024)).str().c_str()); 
     206                         
     207                        SetItemText(itemPos, 3, (hal::wform(L"%1$.2fkb/s") % ((*i).speed.second/1024)).str().c_str()); 
    208208                         
    209209                        if ((*i).seed) 
  • trunk/src/HaliteDialog.hpp

    r710 r715  
    5454                friend class listClass; 
    5555                 
    56                 struct ColumnAdapters 
     56/*              struct ColumnAdapters 
    5757                { 
    5858                 
     
    7878                 
    7979                }; 
    80          
     80*/       
    8181        public:  
    8282                enum {  
     
    128128                        load_from_ini(); 
    129129                         
    130                         SetColumnSortType(2, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedDown()); 
    131                         SetColumnSortType(3, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedUp()); 
     130//                      SetColumnSortType(2, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedDown()); 
     131//                      SetColumnSortType(3, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedUp()); 
    132132                                 
    133133                        return true; 
  • trunk/src/HaliteListView.cpp

    r714 r715  
    1212#include "Halite.hpp" 
    1313 
     14#include "halTorrent.hpp" 
     15 
    1416#include "HaliteListView.hpp" 
    1517#include "HaliteWindow.hpp" 
    1618#include "HaliteListViewDlg.hpp" 
    17  
    18 #include "halTorrent.hpp" 
    1919 
    2020#define HAL_CUSTOMDRAW_TITLEDATA 1000000000 
     
    8686} 
    8787 
     88bool HaliteListViewCtrl::less( std::wstring l,  std::wstring r, size_t index) 
     89{ 
     90        return l < r; 
     91} 
     92 
    8893void HaliteListViewCtrl::uiUpdate(const hal::torrent_details_manager& tD) 
    8994{ 
     
    112117 
    113118        if (IsGroupViewEnabled()) 
    114                 tD.sort(hal::torrent_details::managed_e); 
     119                sort(hal::torrent_details::managed_e); 
    115120 
    116121        bool sort_once = IsSortOnce(); 
     
    160165                lvItem.iImage = 0; 
    161166 
    162                 if (item_pos < 0 || GetItemCount() <= static_cast<int>(item_pos)) 
     167                item_pos = InsertKeyItem(td->name(), &lvItem); 
     168 
     169/*              if (item_pos < 0 || GetItemCount() <= static_cast<int>(item_pos)) 
    163170                { 
    164171                        lvItem.iItem = GetItemCount(); 
     
    170177                        SetItem(&lvItem); 
    171178                } 
    172          
     179*/       
    173180                for (size_t i=1; i<NumberOfColumns_s; ++i) 
    174181                { 
  • trunk/src/HaliteListView.hpp

    r690 r715  
    3838 
    3939class HaliteListViewCtrl : 
    40         public CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::torrent_details_ptr>, 
     40        public CHaliteSortListViewCtrl<HaliteListViewCtrl, std::wstring >, 
    4141        public WTL::CCustomDraw<HaliteListViewCtrl>, 
    4242        private hal::IniBase<HaliteListViewCtrl>, 
     
    4646        typedef HaliteListViewCtrl thisClass; 
    4747        typedef hal::IniBase<thisClass> iniClass; 
    48         typedef CHaliteSortListViewCtrl<thisClass, const hal::torrent_details_ptr> listClass; 
     48        typedef CHaliteSortListViewCtrl<thisClass, std::wstring > listClass; 
    4949        typedef WTL::CCustomDraw<thisClass> ownDrawClass; 
    5050 
     
    122122    } 
    123123 
     124        bool less( std::wstring l,  std::wstring r, size_t index); 
     125 
    124126private: 
    125127        void queue_view_mode(); 
  • trunk/src/HaliteSortListViewCtrl.hpp

    r711 r715  
    1616#include <boost/ptr_container/ptr_map.hpp> 
    1717 
     18#include <boost/detail/iterator.hpp> 
     19#include <boost/multi_index_container.hpp> 
     20#include <boost/multi_index/identity.hpp> 
     21#include <boost/multi_index/ordered_index.hpp> 
     22#include <boost/multi_index/member.hpp> 
     23#include <boost/multi_index/random_access_index.hpp> 
     24 
    1825#include <winstl/controls/listview_sequence.hpp> 
    1926 
     
    3441namespace hal 
    3542{ 
    36  
     43/* 
    3744template<typename T> 
    3845int compare(const T& l, const T& r) 
     
    4552                return -1; 
    4653} 
     54*/ 
    4755 
    4856} 
    49  
    50 template <class TBase, typename AdapterType=void*> 
     57template <class TBase, typename DataType=void*> 
    5158class CHaliteSortListViewCtrl :  
    5259        public ATL::CWindowImpl<TBase, WTL::CListViewCtrl>, 
    53         public WTLx::ListViewIterators<CHaliteSortListViewCtrl<TBase, AdapterType> >, 
    54         public WTLx::ListViewSortMixin<CHaliteSortListViewCtrl<TBase, AdapterType> > 
     60        public WTLx::ListViewIterators<CHaliteSortListViewCtrl<TBase, DataType> >, 
     61        public WTLx::ListViewSortMixin<CHaliteSortListViewCtrl<TBase, DataType> > 
    5562{ 
    5663public: 
    57         typedef CHaliteSortListViewCtrl<TBase, AdapterType> thisClass; 
     64        typedef CHaliteSortListViewCtrl<TBase, DataType> thisClass; 
    5865        typedef ATL::CWindowImpl<TBase, WTL::CListViewCtrl> parentClass; 
    5966        typedef WTLx::ListViewSortMixin<thisClass> listClass; 
     
    109116        }; 
    110117         
    111         struct ColumnAdapter 
     118/*      struct ColumnAdapter 
    112119        { 
    113120                virtual int compare(AdapterType& l, AdapterType& r) = 0; 
    114121                virtual std::wstring print(AdapterType& t) = 0; 
    115122        }; 
     123*/ 
    116124 
    117125public: 
     
    150158        { 
    151159                ATLASSERT(::IsWindow(hWndNew)); 
    152         parentClass::SubclassWindow(hWndNew); 
     160                parentClass::SubclassWindow(hWndNew); 
    153161 
    154162                TBase* pT = static_cast<TBase*>(this); 
     
    361369 
    362370                if (mod_value) sort_once_ = false; 
    363                 return true; 
     371                        return true; 
    364372        } 
    365373 
     
    411419        } 
    412420 
    413         void SetColumnSortType(int iCol, WORD wType, ColumnAdapter* colAdapter=NULL) 
     421        void SetColumnSortType(int iCol, WORD wType, void* colAdapter=NULL) 
    414422        { 
    415423                listClass::SetColumnSortType(iCol, wType); 
    416424                 
    417                 if (WTL::LVCOLSORT_CUSTOM == wType) 
    418                         regColumnAdapter(iCol, colAdapter); 
     425        //      if (WTL::LVCOLSORT_CUSTOM == wType) 
     426        //              regColumnAdapter(iCol, colAdapter); 
    419427        } 
    420428 
     
    504512    } 
    505513 
    506     BOOST_SERIALIZATION_SPLIT_MEMBER() 
     514        BOOST_SERIALIZATION_SPLIT_MEMBER() 
    507515 
    508516        const SelectionManager& manager() { return manager_; } 
     
    541549        } 
    542550*/               
    543         ColumnAdapter* getColumnAdapter(size_t index) 
     551/*      ColumnAdapter* getColumnAdapter(size_t index) 
    544552        { 
    545553                boost::ptr_map<size_t, ColumnAdapter>::iterator  
     
    552560                return NULL; 
    553561        } 
    554  
     562*/ 
    555563        static bool is_selected (const winstl::listview_sequence::sequence_value_type& v)  
    556564        {  
     
    575583        } 
    576584*/ 
    577         void regColumnAdapter(size_t key, ColumnAdapter* colAdapter) 
     585/*      void regColumnAdapter(size_t key, ColumnAdapter* colAdapter) 
    578586        { 
    579587                assert (colAdapter); 
    580588                column_adapters_.insert(key, colAdapter); 
    581589        } 
    582  
     590*/ 
    583591//      AdapterType convert(const LPLVITEM item); 
    584592//      void convert(LPLVITEM item, AdapterType adapter); 
     
    593601        WTL::CMenu menu_; 
    594602        CHaliteHeaderCtrl header_;       
     603 
     604        template<typename T> 
     605        class implicit_reference_wrapper : public boost::reference_wrapper<T> 
     606        { 
     607        private: 
     608                typedef boost::reference_wrapper<T> super; 
     609 
     610        public: 
     611                implicit_reference_wrapper(T& t) : super(t) {} 
     612        }; 
     613 
     614        template <typename T> 
     615        bool imp_less(const implicit_reference_wrapper<T>& l, const implicit_reference_wrapper<T>& r, size_t index)  
     616        { 
     617                TBase* pT = static_cast<TBase*>(this); 
     618 
     619                return pT->less(static_cast<T>(l).second, static_cast<T>(r).second, index); 
     620        //      return static_cast<T>(l) < static_cast<T>(r); 
     621        } 
     622 
     623        struct by_key {}; 
     624        typedef std::pair<bool, DataType> list_pair_t; 
     625 
     626        typedef boost::multi_index_container< 
     627                list_pair_t, 
     628                boost::multi_index::indexed_by< 
     629                        boost::multi_index::random_access<>, 
     630                        boost::multi_index::ordered_unique< 
     631                                boost::multi_index::tag<by_key>,   
     632                                boost::multi_index::member<list_pair_t, DataType, &list_pair_t::second> > 
     633                > 
     634        > pair_container; 
     635 
     636        typedef typename boost::multi_index::nth_index<pair_container, 0>::type ordered_text; 
     637 
     638        int InsertKeyItem(DataType key, LVITEM* pItem) 
     639        { 
     640                list_pair_t lp = std::make_pair(false, key); 
     641 
     642                pair_container::index_iterator<by_key>::type i = pair_container_.get<by_key>().find(key); 
     643                pair_container::iterator i_pos = pair_container_.project<0>(i); 
     644 
     645                if (i != pair_container_.get<by_key>().end()) 
     646                { 
     647                        pItem->iItem = std::distance(pair_container_.begin(), i_pos); 
     648                        SetItem(pItem); 
     649                } 
     650                else 
     651                { 
     652                        pItem->iItem = GetItemCount(); 
     653 
     654                        int list_pos = InsertItem(pItem); 
     655                        pair_container_.push_back(lp); 
     656 
     657                //      assert(list_pos == i_pos); 
     658                } 
     659 
     660                ATLASSERT(::IsWindow(m_hWnd)); 
     661                return 8; 
     662        } 
     663 
     664        void insert_key(DataType key) 
     665        { 
     666                pair_container_.insert(std::make_pair(false, key)); 
     667        } 
     668 
     669        bool data_type_less(list_pair_t r, list_pair_t l, size_t index) 
     670        { 
     671                TBase* pT = static_cast<TBase*>(this); 
     672 
     673                return pT->less((l).second, (r).second, index); 
     674        } 
     675 
     676        void sort(size_t index) 
     677        { 
     678                std::vector<implicit_reference_wrapper<const list_pair_t> > sv; 
     679 
     680                std::copy(pair_container_.begin(), pair_container_.end(), std::back_inserter(sv)); 
     681 
     682//              ordered_text& ot=boost::multi_index::get<0>(pair_container_); 
     683 
     684                std::stable_sort(sv.begin(),  
     685                        sv.end(),  
     686                        bind(&thisClass::data_type_less, this, _1, _2, index)); 
     687 
     688                pair_container_.rearrange(sv.begin()); 
     689        } 
    595690         
    596691private: 
     692        mutable pair_container pair_container_; 
     693 
    597694        bool vector_size_pre_conditions() 
    598695        { 
     
    614711        mutable int sortCol_; 
    615712                 
    616         boost::ptr_map<size_t, ColumnAdapter> column_adapters_; 
     713//      boost::ptr_map<size_t, ColumnAdapter> column_adapters_; 
    617714}; 
    618715 
     
    626723namespace boost { 
    627724namespace serialization { 
    628         template <class TBase, typename AdapterType> 
    629         struct version< CHaliteSortListViewCtrl<TBase, AdapterType> > 
     725        template <class TBase, typename AdapterTypeI> 
     726        struct version< CHaliteSortListViewCtrl<TBase, AdapterTypeI> > 
    630727        { 
    631728                typedef mpl::int_<2> type; 
Note: See TracChangeset for help on using the changeset viewer.