Changeset 255


Ignore:
Timestamp:
08/16/07 13:11:17 (13 years ago)
Author:
Eoin
Message:

Auto-sorting for listviews supported

Files:
10 edited

Legend:

Unmodified
Added
Removed
  • res/resource.h

    r254 r255  
    33#endif 
    44 
    5 #define HALITE_VERSION                                  0,2,9,249 
    6 #define HALITE_VERSION_STRING                   "v 0.2.9 dev 249" 
     5#define HALITE_VERSION                                  0,2,9,255 
     6#define HALITE_VERSION_STRING                   "v 0.2.9 dev 255" 
    77 
    88#define HALITE_LANGUAGE                                 10 
  • src/AdvHaliteDialog.hpp

    r240 r255  
    2424class AdvHaliteDialog : 
    2525        public CDialogImpl<AdvHaliteDialog>, 
    26         public CDialogResize<AdvHaliteDialog> 
     26        private CDialogResize<AdvHaliteDialog> 
    2727{ 
    2828protected: 
     
    3030        typedef CDialogImpl<AdvHaliteDialog> baseClass; 
    3131        typedef CDialogResize<AdvHaliteDialog> resizeClass; 
     32        friend class resizeClass; 
    3233public: 
    3334        enum { IDD = IDD_ADVHALITEDLG }; 
  • src/Halite.cpp

    r221 r255  
    2020static class halite_log_file : public boost::signals::trackable 
    2121{ 
    22 public: 
    23         halite_log_file(); 
    24          
     22public:  
    2523        void operator()(shared_ptr<hal::EventDetail> event) 
    2624        { 
     
    3735        } 
    3836         
     37        void connect()  
     38        {  
     39                conn_ = hal::event().attach(bind(&halite_log_file::operator(), this, _1));  
     40                assert(conn_.connected()); 
     41        } 
     42         
    3943        void disconnect() { conn_.disconnect(); } 
    4044         
    4145private: 
    4246        std::wofstream wofs; 
    43         boost::signals::scoped_connection conn_; 
     47        boost::signals::connection conn_; 
    4448         
    4549} halite_log_file_; 
    46  
    47 halite_log_file::halite_log_file() : 
    48         conn_(hal::event().attach(bind(&halite_log_file::operator(), &halite_log_file_, _1))) 
    49 {} 
    5050 
    5151static const unsigned WMU_ARE_YOU_ME = ::RegisterWindowMessage(WMU_ARE_YOU_ME_STRING); 
     
    127127                        if (halite().dll() != L"") hal::app().set_res_dll(halite().dll()); 
    128128                         
     129                        halite_log_file_.connect(); 
     130                         
    129131                        HaliteWindow wndMain(WMU_ARE_YOU_ME); 
    130132                        if (wndMain.CreateEx() == NULL) 
  • src/HaliteDialog.cpp

    r253 r255  
    216216                 
    217217                int iCol = GetSortColumn(); 
    218                 if (iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
     218                if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
    219219                        DoSortItems(iCol, IsSortDescending()); 
    220220        } 
  • src/HaliteListView.cpp

    r252 r255  
    6161void HaliteListViewCtrl::uiUpdate(const hal::TorrentDetails& tD) 
    6262{ 
    63         if (canUpdate()) 
     63        TryUpdateLock<listClass> lock(*this); 
     64        if (lock)  
    6465        { 
    65         UpdateLock<listClass> rLock(*this); 
    6666         
    6767        foreach (const hal::TorrentDetail_ptr td, tD.torrents())  
     
    8080                } 
    8181        } 
     82         
     83        int iCol = GetSortColumn(); 
     84        if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
     85                DoSortItems(iCol, IsSortDescending()); 
    8286         
    8387        } 
  • src/HaliteListView.hpp

    r252 r255  
    1717class HaliteListViewCtrl : 
    1818        public CHaliteSortListViewCtrl<HaliteListViewCtrl, const hal::TorrentDetail_ptr>, 
    19         public CHaliteIni<HaliteListViewCtrl>, 
     19        private CHaliteIni<HaliteListViewCtrl>, 
    2020        private boost::noncopyable 
    2121{ 
     
    7979        struct Peers : public ColAdapter_t 
    8080        { 
    81                 virtual bool less(tD& l, tD& r) { return l->peers() < r->seeds(); }              
     81                virtual bool less(tD& l, tD& r) { return l->peers() < r->peers(); }              
    8282                virtual std::wstring print(tD& t) { return lexical_cast<wstring>(t->peers()); }          
    8383        }; 
     
    8585        struct Seeds : public ColAdapter_t 
    8686        { 
    87                 virtual bool less(tD& l, tD& r) { return l->distributedCopies() < r->distributedCopies(); }              
     87                virtual bool less(tD& l, tD& r) { return l->seeds() < r->seeds(); }              
    8888                virtual std::wstring print(tD& t) { return lexical_cast<wstring>(t->seeds()); }          
    8989        }; 
  • src/HaliteSortListViewCtrl.hpp

    r254 r255  
    342342        thisClass(bool resMenu=true, bool resNames=true, bool resWidthsAndOrder=true) : 
    343343                manager_(*this), 
    344                 updateLock_(0) 
    345         { 
     344                updateLock_(0), 
     345                autoSort_(false) 
     346        {                
     347                if (resMenu && TBase::LISTVIEW_ID_MENU) 
     348                { 
     349                        CMenuHandle menu; 
     350                        BOOL menu_created = menu.LoadMenu(TBase::LISTVIEW_ID_MENU); 
     351                        assert(menu_created);    
     352                         
     353                        menu_.Attach(menu.GetSubMenu(0)); 
     354                } 
     355 
     356 
     357                if (resNames) 
     358                { 
     359                        wstring column_names = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNNAMES); 
     360                        boost::split(listNames_, column_names, boost::is_any_of(L";")); 
     361                } 
     362                 
     363                if (resWidthsAndOrder) 
     364                { 
     365                        wstring column_widths = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNWIDTHS); 
     366                        std::vector<wstring> widths; 
     367                        boost::split(widths, column_widths, boost::is_any_of(L";")); 
     368                         
     369                        listWidths_.reserve(listNames_.size());  
     370                        listOrder_.reserve(listNames_.size()); 
     371                         
     372                        for (size_t i=0; i<listNames_.size(); ++i) 
     373                        { 
     374                                listWidths_.push_back(lexical_cast<int>(widths[i])); 
     375                                listOrder_.push_back(i); 
     376                        } 
     377                } 
     378        } 
     379 
     380        BEGIN_MSG_MAP_EX(thisClass) 
     381                COMMAND_ID_HANDLER(ID_LVM_AUTOSORT, OnAutoSort) 
     382                 
     383        //      REFLECTED_NOTIFY_CODE_HANDLER(NM_CLICK, OnClick) 
     384                REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick) 
     385                REFLECTED_NOTIFY_CODE_HANDLER(LVN_ITEMCHANGED, OnItemChanged) 
     386        //      REFLECTED_NOTIFY_CODE_HANDLER(LVN_COLUMNCLICK , OnColClick) 
     387 
     388                DEFAULT_REFLECTION_HANDLER() 
     389                CHAIN_MSG_MAP(parentClass) 
     390        END_MSG_MAP() 
     391 
     392        void Attach(HWND hWndNew) 
     393        { 
     394                ATLASSERT(::IsWindow(hWndNew)); 
     395        parentClass::SubclassWindow(hWndNew); 
     396 
     397                TBase* pT = static_cast<TBase*>(this); 
     398                pT->OnAttach(); 
     399        } 
     400         
     401        void SetListViewDetails() 
     402        { 
     403                vectorSizePreConditions(); 
     404                 
     405                header_.Attach(this->GetHeader()); 
     406                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG); 
     407                         
     408                foreach (wstring name, listNames_) 
     409                { 
     410                        int i = header_.GetItemCount(); 
     411                         
     412                        AddColumn(name.c_str(), i); 
     413                }                
     414 
     415                for (unsigned i=0; i<listNames_.size(); ++i) 
     416                        SetColumnWidth(i, listOrder_[i]); 
     417                 
     418                SetColumnOrderArray(listOrder_.size(), &listOrder_[0]);  
     419        } 
     420         
     421        template<typename N, typename W, typename O, typename P> 
     422        void SetDefaults(N nameList, W widthList, O orderList, P visibleList, bool autoSort=false) 
     423        { 
     424                listNames_.assign(nameList.begin(), nameList.end()); 
     425                listWidths_.assign(widthList.begin(), widthList.end()); 
     426                listOrder_.assign(orderList.begin(), orderList.end()); 
     427                listVisible_.assign(visibleList.begin(), visibleList.end()); 
     428                 
     429                autoSort_ = autoSort; 
     430        } 
     431         
     432        template<std::size_t Size> 
     433        void SetDefaults(array<int, Size> a) 
     434        { 
     435                assert (Size == listNames_.size()); 
     436                vectorSizePreConditions(); 
     437                 
     438                for (size_t i=0; i<listNames_.size(); ++i) 
     439                { 
     440                        listWidths_[i] = a[i]; 
     441                        listOrder_[i] = i; 
     442                }                
     443        } 
     444         
     445        void ApplyDetails() 
     446        { 
     447                vectorSizePreConditions(); 
     448                 
    346449                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    347                  
    348                 if (resMenu && TBase::LISTVIEW_ID_MENU) 
    349                 { 
    350                         BOOL menu_created = menu_.LoadMenu(TBase::LISTVIEW_ID_MENU); 
    351                         assert(menu_created);    
    352                          
    353                         menu_ = menu_.GetSubMenu(0); 
    354                 } 
    355450                 
    356451                if (!menu_) 
     
    368463                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE; 
    369464                minfo.fType = MFT_STRING; 
    370                 minfo.fState = MFS_CHECKED; 
     465                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
    371466                minfo.wID = ID_LVM_AUTOSORT; 
    372467                 
     
    375470                 
    376471                menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo); 
    377  
    378                 if (resNames) 
    379                 { 
    380                         wstring column_names = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNNAMES); 
    381                         boost::split(listNames_, column_names, boost::is_any_of(L";")); 
    382                 } 
    383                  
    384                 if (resWidthsAndOrder) 
    385                 { 
    386                         wstring column_widths = hal::app().res_wstr(TBase::LISTVIEW_ID_COLUMNWIDTHS); 
    387                         std::vector<wstring> widths; 
    388                         boost::split(widths, column_widths, boost::is_any_of(L";")); 
    389                          
    390                         listWidths_.reserve(listNames_.size());  
    391                         listOrder_.reserve(listNames_.size()); 
    392                          
    393                         for (size_t i=0; i<listNames_.size(); ++i) 
    394                         { 
    395                                 listWidths_.push_back(lexical_cast<int>(widths[i])); 
    396                                 listOrder_.push_back(i); 
    397                         } 
    398                 } 
    399         } 
    400  
    401         BEGIN_MSG_MAP_EX(thisClass) 
    402         //      REFLECTED_NOTIFY_CODE_HANDLER(NM_CLICK, OnClick) 
    403                 REFLECTED_NOTIFY_CODE_HANDLER(NM_RCLICK, OnRClick) 
    404                 REFLECTED_NOTIFY_CODE_HANDLER(LVN_ITEMCHANGED, OnItemChanged) 
    405         //      REFLECTED_NOTIFY_CODE_HANDLER(LVN_COLUMNCLICK , OnColClick) 
    406  
    407                 DEFAULT_REFLECTION_HANDLER() 
    408                 CHAIN_MSG_MAP(parentClass) 
    409         END_MSG_MAP() 
    410  
    411         void Attach(HWND hWndNew) 
    412         { 
    413                 ATLASSERT(::IsWindow(hWndNew)); 
    414         parentClass::SubclassWindow(hWndNew); 
    415  
    416                 TBase* pT = static_cast<TBase*>(this); 
    417                 pT->OnAttach(); 
    418         } 
    419          
    420         void SetListViewDetails() 
    421         { 
    422                 vectorSizePreConditions(); 
    423472                 
    424473                header_.Attach(this->GetHeader()); 
    425474                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG); 
    426                          
    427                 foreach (wstring name, listNames_) 
    428                 { 
    429                         int i = header_.GetItemCount(); 
    430                          
    431                         AddColumn(name.c_str(), i); 
    432                 }                
    433  
    434                 for (unsigned i=0; i<listNames_.size(); ++i) 
    435                         SetColumnWidth(i, listOrder_[i]); 
    436                  
    437                 SetColumnOrderArray(listOrder_.size(), &listOrder_[0]);  
    438         } 
    439          
    440         template<typename N, typename W, typename O, typename P> 
    441         void SetDefaults(N nameList, W widthList, O orderList, P visibleList) 
    442         { 
    443                 listNames_.assign(nameList.begin(), nameList.end()); 
    444                 listWidths_.assign(widthList.begin(), widthList.end()); 
    445                 listOrder_.assign(orderList.begin(), orderList.end()); 
    446                 listVisible_.assign(visibleList.begin(), visibleList.end()); 
    447         } 
    448          
    449         template<std::size_t Size> 
    450         void SetDefaults(array<int, Size> a) 
    451         { 
    452                 assert (Size == listNames_.size()); 
    453                 vectorSizePreConditions(); 
    454                  
    455                 for (size_t i=0; i<listNames_.size(); ++i) 
    456                 { 
    457                         listWidths_[i] = a[i]; 
    458                         listOrder_[i] = i; 
    459                 }                
    460         } 
    461          
    462         void ApplyDetails() 
    463         { 
    464                 vectorSizePreConditions(); 
    465                  
    466                 header_.Attach(this->GetHeader()); 
    467                 header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG); 
    468475                 
    469476                for (int i = header_.GetItemCount(); i<listNames_.size(); i = header_.GetItemCount()) 
     
    486493                 
    487494                GetColumnOrderArray(listNames_.size(), &listOrder_[0]); 
     495        } 
     496         
     497        LRESULT OnAutoSort(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
     498        { 
     499                autoSort_ = !autoSort_; 
     500                 
     501                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
     502                 
     503                minfo.fMask = MIIM_STATE; 
     504                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
     505                 
     506                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo); 
     507                 
     508                return 0; 
    488509        } 
    489510 
     
    539560    void serialize(Archive & ar, const unsigned int version) 
    540561    { 
    541         ar & boost::serialization::make_nvp("width", listWidths_); 
    542         ar & boost::serialization::make_nvp("order", listOrder_); 
     562                if (version >= 1) 
     563                { 
     564                        ar & boost::serialization::make_nvp("width", listWidths_); 
     565                        ar & boost::serialization::make_nvp("order", listOrder_); 
     566                        ar & boost::serialization::make_nvp("visible", listVisible_); 
     567                        ar & boost::serialization::make_nvp("autoSort", autoSort_); 
     568                } 
    543569    } 
    544570 
     
    568594                return pT->CustomItemComparision(left, right, iSortCol); 
    569595        } 
     596         
     597        bool autoSort() { return autoSort_; } 
    570598         
    571599protected:       
     
    638666        std::vector<int> listOrder_; 
    639667        std::vector<bool> listVisible_; 
     668        bool autoSort_; 
    640669         
    641670        int updateLock_; 
     
    647676        WinAPIWaitableTimer syncTimer_; 
    648677}; 
     678 
     679namespace boost { 
     680namespace serialization { 
     681template <class TBase, typename adapterType, size_t N> 
     682struct version< CHaliteSortListViewCtrl<TBase, adapterType, N> > 
     683{ 
     684    typedef mpl::int_<1> type; 
     685    typedef mpl::integral_c_tag tag; 
     686    BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);                                                              
     687}; 
     688} 
     689} 
  • src/global/string_conv.hpp

    r145 r255  
    5151} 
    5252 
     53inline std::wstring safe_from_utf8(const std::string& str)  
     54{                
     55        try 
     56        { 
     57         
     58        return mbstowcs(str);  
     59         
     60        } 
     61        catch(...) 
     62        { 
     63         
     64        std::wstring wstr; 
     65        wstr.reserve(str.length()); 
     66         
     67        for (std::string::const_iterator i=str.begin(); i!=str.end(); ++i) 
     68        { 
     69                char narrow_char = *i; 
     70                wchar_t wide_char = 0; 
     71                 
     72                *(reinterpret_cast<char*>(&wide_char)) = narrow_char; 
     73                wstr.push_back(wide_char); 
     74        } 
     75         
     76        return wstr; 
     77         
     78        } 
     79} 
     80 
    5381inline std::wstring from_utf8(const std::string& str)  
    5482{  
  • src/halEvent.hpp

    r233 r255  
    3434        void post(boost::shared_ptr<EventDetail> event); 
    3535         
    36         boost::signals::scoped_connection attach(boost::function<void (shared_ptr<EventDetail>)> fn) 
     36        boost::signals::connection attach(boost::function<void (shared_ptr<EventDetail>)> fn) 
    3737        { 
    3838                return event_signal_.connect(fn); 
  • src/halTorrent.cpp

    r252 r255  
    11141114 
    11151115PeerDetail::PeerDetail(lbt::peer_info& peerInfo) : 
    1116         ipAddress(hal::str_to_wstr(peerInfo.ip.address().to_string())), 
     1116        ipAddress(hal::safe_from_utf8(peerInfo.ip.address().to_string())), 
    11171117        country(L""), 
    11181118        speed(make_pair(peerInfo.payload_down_speed, peerInfo.payload_up_speed)), 
    11191119        seed(peerInfo.seed), 
    1120         client(hal::str_to_wstr(peerInfo.client)) 
     1120        client(hal::safe_from_utf8(peerInfo.client)) 
    11211121{ 
    11221122        std::vector<wstring> status_vec; 
     
    11241124#ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES 
    11251125        if (peerInfo.country[0] != 0 && peerInfo.country[1] != 0) 
    1126                 country = (wformat(L"(%1%)") % hal::str_to_wstr(string(peerInfo.country, 2))).str().c_str(); 
     1126                country = (wformat(L"(%1%)") % hal::safe_from_utf8(string(peerInfo.country, 2))).str().c_str(); 
    11271127#endif   
    11281128 
Note: See TracChangeset for help on using the changeset viewer.