Changeset 654 for trunk

Timestamp:

12/24/08 18:40:39 (11 years ago)

Author:

Eoin

Message:

Sorting on the main listview now working with groups.

Location:

trunk/src

Files:

• HaliteListView.cpp (modified) (3 diffs)
• HaliteListView.hpp (modified) (2 diffs)
• HaliteSortListViewCtrl.hpp (modified) (4 diffs)
• halTorrent.cpp (modified) (1 diff)
• halTorrent.hpp (modified) (5 diffs)

trunk/src/HaliteListView.cpp

@@ -127 +127 @@
         {
 
+                tD.sort(hal::torrent_details::peers_e);
+
+                if (IsGroupViewEnabled())
+                        tD.sort(hal::torrent_details::managed_e);
+
 #       if 0
         if (GetItemCount() > 0)
@@ -148 +153 @@
 #       endif
 
-        foreach (const hal::torrent_details_ptr td, tD.torrents()) 
-        {
-
-                LV_FINDINFO findInfo; 
+        for (size_t td_index=0, e=tD.torrents().size(); td_index<e; ++td_index)
+        {
+                hal::torrent_details_ptr td = tD.torrents()[td_index];
+                /*LV_FINDINFO findInfo; 
                 findInfo.flags = LVFI_STRING;
                 findInfo.psz = const_cast<LPTSTR>(td->name().c_str());
                 
                 int itemPos = FindItem(&findInfo, -1);
-                if (itemPos < 0)
-                {
-                        LVITEM lvItem = { 0 };
-                        lvItem.mask = LVIF_TEXT;
-                        lvItem.iItem = 0;
-                        lvItem.iSubItem = 0;
-                        lvItem.pszText = (LPTSTR)td->name().c_str();
-
-                        if (IsGroupViewEnabled())
-                        {
-                                lvItem.mask |= LVIF_GROUPID|LVIF_COLUMNS;
-
-                                if (td->managed())
-                                        lvItem.iGroupId = HAL_AUTO_MANAGED;
-                                else
-                                        lvItem.iGroupId = HAL_UNMANAGED;
-                        }
-
-                        lvItem.mask |= LVIF_IMAGE;
-                        lvItem.iImage = 0;
-
-                        itemPos = InsertItem(&lvItem);
-                }
-
+                */
+
+                LVITEM lvItem = { 0 };
+                lvItem.mask = LVIF_TEXT;
+                lvItem.iSubItem = 0;
+                lvItem.pszText = (LPTSTR)td->name().c_str();
+
+                if (IsGroupViewEnabled())
+                {
+                        lvItem.mask |= LVIF_GROUPID|LVIF_COLUMNS;
+
+                        if (td->managed())
+                                lvItem.iGroupId = HAL_AUTO_MANAGED;
+                        else
+                                lvItem.iGroupId = HAL_UNMANAGED;
+                }
+
+                lvItem.mask |= LVIF_IMAGE;
+                lvItem.iImage = 0;
+
+                if (GetItemCount() <= static_cast<int>(td_index))
+                {
+                        lvItem.iItem = GetItemCount();
+                        td_index = InsertItem(&lvItem);
+                }
+                else
+                {
+                        lvItem.iItem = td_index;
+                        SetItem(&lvItem);
+                }
+        
                 for (size_t i=1; i<NumberOfColumns_s; ++i)
                 {
-                        SetItemText(itemPos, i, getColumnAdapter(i)->print(td).c_str());
+                        SetItemText(td_index, i, td->to_wstring(i).c_str());
                 }
         }
@@ -191 +203 @@
 */      
         }
+}
+
+void HaliteListViewCtrl::SortByColumn(size_t column_index)
+{
+        //std::sort(data_elements_.begin(), data_elements_.end(), 
+        //      );
+        
 }
 

trunk/src/HaliteListView.hpp

@@ -442 +442 @@
                 ar & make_nvp("queue_view", queue_view_);
     }
-        
+
+        void SortByColumn(size_t column_index);
+
 /*      tD CustomItemConversion(LVCompareParam* param, int iSortCol);
 
@@ -460 +462 @@
         
         enum { NumberOfColumns_s = 23 };
+
+        std::vector<const hal::torrent_details_ptr> data_elements_;
         
         HaliteWindow& halWindow_;

trunk/src/HaliteSortListViewCtrl.hpp

@@ -59 +59 @@
         {
         public:
-                enum { COL_MENU_NAMES = 123, COL_MAX_NAMES = 256};
+                enum { COL_MENU_NAMES = 123, COL_MAX_NAMES = 256 };
 
                 CHaliteHeaderCtrl(thisClass& listView) :
@@ -98 +98 @@
                         minfo.fState = visible ? MFS_CHECKED : MFS_UNCHECKED;
                 
-                        menu_.SetMenuItemInfo(wID, false, &minfo);*/
-
+                        menu_.SetMenuItemInfo(wID, false, &minfo);
+                */
                         return 0;
                 }
@@ -425 +425 @@
         }
 
+        void SortByColumn(size_t column_index)
+        {
+                /* Overwriteable */
+        }
+
         int AddColumn(LPCTSTR strItem, int nItem, bool visible, int width=-1)
         {
@@ -436 +441 @@
                         int nFmt = LVCFMT_LEFT, bool visible=true, int width=-1)
         {
-
                 int i = parentClass::AddColumn(strItem, nItem, nSubItem, nMask, nFmt);
 

trunk/src/halTorrent.cpp

@@ -61 +61 @@
 }
 
-void torrent_details_manager::sort(
-        boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const
-{
-        std::stable_sort(torrents_.begin(), torrents_.end(), fn);
+bool torrent_details::less(const torrent_details& r, size_t index)
+{
+        switch (index)
+        {
+        case name_e: return name_ < r.name_;
+        case state_e: return state_ < r.state_;
+
+        case speed_down_e: return speed_.first < r.speed_.first;
+        case speed_up_e: return speed_.second < r.speed_.second;
+        case progress_e: return completion_ < r.completion_;
+        case distributed_copies_e: return distributed_copies_ < r.distributed_copies_;
+
+        case remaining_e: 
+                {
+                boost::int64_t left = totalWanted_-totalWantedDone_;
+                boost::int64_t right = r.totalWanted_-r.totalWantedDone_;
+
+                return left < right;
+                }
+
+        case total_wanted_e: return totalWanted_ < r.totalWanted_;
+        case completed_e: return totalWantedDone_ < r.totalWantedDone_; 
+
+        case uploaded_e: return totalUploaded_ < r.totalUploaded_;
+        case downloaded_e: return totalPayloadUploaded_ < r.totalPayloadUploaded_;
+
+        case peers_e: return peers_ < r.peers_;
+        case seeds_e: return seeds_ < r.seeds_;
+
+        case ratio_e: 
+                {
+                float left = (totalPayloadDownloaded_) 
+                                ? static_cast<float>(totalPayloadUploaded_)
+                                        / static_cast<float>(totalPayloadDownloaded_)
+                                : 0;
+                
+                float right = (r.totalPayloadDownloaded_) 
+                                ? static_cast<float>(r.totalPayloadUploaded_)
+                                        / static_cast<float>(r.totalPayloadDownloaded_)
+                                : 0;
+                
+                return left < right; 
+                }
+
+        case eta_e: return estimatedTimeLeft_ < r.estimatedTimeLeft_;
+        case tracker: return currentTracker_ < r.currentTracker_;
+        case update_tracker_in_e: return updateTrackerIn_ < r.updateTrackerIn_;
+
+        case active_time_e: return active_ < r.active_;
+        case seeding_time_e: return seeding_ < r.seeding_;
+        case start_time_e: return startTime_ < r.startTime_;
+        case finish_time_e: return finishTime_ < r.finishTime_;
+
+        case queue_position_e: return queue_position_ < r.queue_position_;
+        case managed_e: return managed_ < r.managed_;
+
+        default: return false; // ???
+        };
+}
+
+std::wstring torrent_details::to_wstring(size_t index)
+{
+        switch (index)
+        {
+        case name_e: return name_;
+        case state_e: return state_;
+
+        case progress_e: return (wform(L"%1$.2f%%") % (completion_*100)).str(); 
+        case speed_down_e: return (wform(L"%1$.2fkb/s") % (speed_.first/1024)).str(); 
+        case speed_up_e: return (wform(L"%1$.2fkb/s") % (speed_.second/1024)).str(); 
+
+        case distributed_copies_e: 
+                {
+                float copies = distributed_copies_;
+                
+                if (copies < 0)
+                        return L"Seeding"; 
+                else
+                        return (hal::wform(L"%1$.2f") % copies).str();  
+                }
+
+        case remaining_e: 
+                {
+                return (wform(L"%1$.2fMB") % (static_cast<float>(totalWanted_-totalWantedDone_)/(1024*1024))).str(); 
+                }
+
+        case completed_e: return (wform(L"%1$.2fMB") % (static_cast<float>(totalWantedDone_)/(1024*1024))).str();
+
+        case total_wanted_e: 
+                {
+                return (wform(L"%1$.2fMB") % (static_cast<float>(totalWanted_-totalWantedDone_)/(1024*1024))).str(); 
+                }
+
+        case uploaded_e: 
+                {
+                return (wform(L"%1$.2fMB") % (static_cast<float>(totalPayloadUploaded_)/(1024*1024))).str(); 
+                }
+
+        case downloaded_e: 
+                {
+                return (wform(L"%1$.2fMB") % (static_cast<float>(totalPayloadDownloaded_)/(1024*1024))).str(); 
+                }
+
+        case peers_e: return (wform(L"%1% (%2%)") % connectedPeers_ % peers_).str(); 
+        case seeds_e: return (wform(L"%1% (%2%)") % connectedSeeds_ % seeds_).str(); 
+
+        case ratio_e: 
+                {
+                        float ratio = (totalPayloadDownloaded_) 
+                                ? static_cast<float>(totalPayloadUploaded_)
+                                        / static_cast<float>(totalPayloadDownloaded_)
+                                : 0;
+                        
+                        return (wform(L"%1$.2f") % ratio).str(); 
+                }
+
+        case eta_e: 
+                { 
+                if (!estimatedTimeLeft_.is_special())
+                        return hal::from_utf8(
+                                boost::posix_time::to_simple_string(estimatedTimeLeft_));
+                else
+                        return app().res_wstr(HAL_INF);         
+                }       
+
+        case tracker: return currentTracker_;
+
+        case update_tracker_in_e:               
+                { 
+                if (!updateTrackerIn_.is_special())
+                        return from_utf8(
+                                boost::posix_time::to_simple_string(updateTrackerIn_));
+                else
+                        return app().res_wstr(HAL_INF);         
+                }       
+
+        case active_time_e: 
+                {
+                if (!active_.is_special())
+                        return from_utf8(
+                                boost::posix_time::to_simple_string(active_));
+                else
+                        return app().res_wstr(HAL_INF);         
+                }
+
+        case seeding_time_e: 
+                { 
+                if (!seeding_.is_special())
+                        return from_utf8(
+                                boost::posix_time::to_simple_string(seeding_));
+                else
+                        return app().res_wstr(HAL_INF);
+                }       
+
+        case start_time_e: 
+                { 
+                if (!startTime_.is_special())
+                        return from_utf8(
+                                boost::posix_time::to_simple_string(startTime_));
+                else
+                        return app().res_wstr(IDS_NA);
+                }               
+
+        case finish_time_e:             
+                { 
+                if (!finishTime_.is_special())
+                        return from_utf8(
+                                boost::posix_time::to_simple_string(finishTime_));
+                else
+                        return app().res_wstr(IDS_NA);  
+                }               
+
+        case queue_position_e: 
+                {
+                        if (queue_position_ != -1)
+                                return (wform(L"%1%") % queue_position_).str(); 
+                        else
+                                return app().res_wstr(IDS_NA);          
+                }
+
+        case managed_e:
+                { 
+                if (managed_)
+                        return L"Yes";
+                else
+                        return L"No";   
+                }       
+
+        default: return L"(Undefined)"; // ???
+        };
+}
+
+template<typename torrent_Tptr>
+bool torrent_details_less(torrent_Tptr l, torrent_Tptr r, size_t index = 0)
+{
+        return l->less(*r, index);
+}
+
+void torrent_details_manager::sort(size_t column_index) const
+{
+        std::stable_sort(torrents_.begin(), torrents_.end(), 
+                bind(&torrent_details_less<torrent_details_ptr>, _1, _2, column_index));
 }
 

trunk/src/halTorrent.hpp

@@ -393 +393 @@
                         std::wstring cT, 
                         std::pair<float,float> sp=std::pair<float,float>(0,0),
-                        float c=0,      float d=0, 
+                        float c=0, float d=0, 
                         size_type tWD=0, size_type tW=0, 
                         size_type tU=0, size_type tpU=0, 
@@ -452 +452 @@
                 torrent_stopping
         };
+
+        enum details
+        {
+                name_e = 0,
+                state_e,
+                progress_e,
+                speed_down_e,
+                speed_up_e,
+                peers_e,
+                seeds_e,
+                eta_e,
+                distributed_copies_e,
+                tracker,
+                update_tracker_in_e,
+                ratio_e,
+                total_wanted_e,
+                completed_e,
+                remaining_e,
+                downloaded_e,
+                uploaded_e,
+                active_time_e,
+                seeding_time_e,
+                start_time_e,
+                finish_time_e,
+                managed_e,
+                queue_position_e
+        };
+
         
 //      const std::wstring& filename() const { return filename_; }
@@ -490 +518 @@
         int queue_position() const { return queue_position_; }
         bool managed() const { return managed_; }
+
+        bool less(const torrent_details& r, size_t index = 0);
+        std::wstring to_wstring(size_t index = 0);
         
 public:
@@ -544 +575 @@
 {
 public: 
-        void sort(boost::function<bool (const torrent_details_ptr&, const torrent_details_ptr&)> fn) const;
+        void sort(size_t index) const;
         
         const torrent_details_vec torrents() const 
@@ -581 +612 @@
         void clearAll(const mutex_t::scoped_lock&)
         {
-                // !! No mutex lock, it should only be call from functions which 
+                // !! No mutex lock, it should only be called from functions which 
                 // have the lock themselves, hence the unused function param