Changeset 614 for trunk


Ignore:
Timestamp:
11/01/08 14:05:03 (11 years ago)
Author:
Eoin
Message:

ListView? grouping works. But a lacking on the API side means it's incompatible with sorting!

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/res/Halite.rc

    r612 r614  
    436436    PUSHBUTTON      "Cancel",IDCANCEL,155,65,62,13 
    437437 
    438 //    CONTROL         "Use Compact Allocation.",HAL_CHECK_COMPACT,"Button",BS_AUTOCHECKBOX|WS_TABSTOP,5,38,220,8|NOT WS_VISIBLE 
    439     COMBOBOX        HAL_STORAGE_TYPE_COMBO,5,38,220,58,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP 
     438    CONTROL         "Managed Torrent",HAL_ADDT_CHECK_MANAGED,"Button",BS_AUTOCHECKBOX|WS_TABSTOP,5,38,220,8|NOT WS_VISIBLE 
     439        LTEXT           "Allocation Mode:",HAL_ADDT_ALLOC_MODE,6,51,215,8,SS_WORDELLIPSIS|SS_CENTERIMAGE 
     440    COMBOBOX        HAL_ADDT_ALLOC_COMBO,5,38,220,58,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP 
    440441    CONTROL         "Stopped initially (Allows changing advanced setting)",HAL_CHECK_PAUSED,"Button",BS_AUTOCHECKBOX|WS_TABSTOP,5,25,220,8 
    441442    LTEXT           "Note. Compact Allocation is incompatible with File Selection",HAL_ADDT_NOTE_TEXT,6,51,215,8,SS_WORDELLIPSIS|SS_CENTERIMAGE 
     
    795796STRINGTABLE 
    796797BEGIN 
    797         HAL_LISTVIEW_COLUMNS                    "Name;Status;Progress;Download;Upload;Peers;Seeds;ETA;Copies;Tracker;Reannounce;Ratio;Total;Completed;Remaining;Downloaded;Uploaded;Active;Seeding;Start Time;Finish Time;Queue Position" 
     798        HAL_LISTVIEW_COLUMNS                    "Name;Status;Progress;Download;Upload;Peers;Seeds;ETA;Copies;Tracker;Reannounce;Ratio;Total;Completed;Remaining;Downloaded;Uploaded;Active;Seeding;Start Time;Finish Time;Managed;Queue Position" 
    798799        HAL_DEBUG_LISTVIEW_COLUMNS              "Time;Message;Severity" 
    799800        HAL_TRACKER_LISTVIEW_COLUMNS    "Tracker;Tier" 
  • trunk/src/AddTorrentDialog.hpp

    r612 r614  
    99#define ID_ADD_TORRENT_BEGIN            11000 
    1010#define HAL_ADJUST_DLG_HOLDER           ID_ADD_TORRENT_BEGIN + 1 
    11 #define HAL_STORAGE_TYPE_COMBO          ID_ADD_TORRENT_BEGIN + 2 
     11#define HAL_ADDT_ALLOC_COMBO            ID_ADD_TORRENT_BEGIN + 2 
     12#define HAL_ADDT_CHECK_MANAGED          ID_ADD_TORRENT_BEGIN + 3 
     13#define HAL_ADDT_ALLOC_MODE                     ID_ADD_TORRENT_BEGIN + 4 
     14 
    1215 
    1316#ifndef RC_INVOKED 
     
    3235 
    3336public: 
    34         AddTorrentDialog(wstring& d, wstring& m, bool& u, bool& p, bool& c, hal::bit::allocations& a_t) :          
     37        AddTorrentDialog(wstring& d, wstring& m, bool& u, bool& p, bool& man, hal::bit::allocations& a_t) :        
    3538                iniClass("AddTorrentDialog", "settings"), 
    3639                rect_(0,0,0,0), 
    3740                adjustDlg_(d, m, u), 
    3841                startPaused_(p), 
    39                 compactStorage_(c), 
     42                managed_(man), 
    4043                allocation_type_(a_t) 
    4144        {  
     
    5760                 
    5861        CHAIN_MSG_MAP(autosizeClass) 
    59 //              AddHeightToComboBox(); 
    6062    END_MSG_MAP() 
    6163         
    6264    BEGIN_DDX_MAP(thisClass) 
    63         DDX_CHECK(HAL_CHECK_COMPACT, compactStorage_) 
     65        DDX_CHECK(HAL_ADDT_CHECK_MANAGED, managed_) 
    6466        DDX_CHECK(HAL_CHECK_PAUSED, startPaused_) 
    65                 DDX_EX_STDWSTRING(HAL_STORAGE_TYPE_COMBO, allocation_type_name_) 
     67                DDX_EX_STDWSTRING(HAL_ADDT_ALLOC_COMBO, allocation_type_name_) 
    6668    END_DDX_MAP()        
    6769 
     
    7173        WMB_END() 
    7274 
     75#define ALLOC_MODE_LAYOUT \ 
     76        WMB_HEAD(WMB_COLNOMAX(_exp|33), WMB_COLNOMAX(_exp)), \ 
     77                WMB_ROW(_auto,  HAL_ADDT_ALLOC_MODE, HAL_ADDT_ALLOC_COMBO), \ 
     78        WMB_END() 
     79 
    7380        BEGIN_WINDOW_MAP(thisClass, 6, 6, 3, 3) 
    7481                WMB_HEAD(WMB_COLNOMAX(_exp)), 
    7582                        WMB_ROW(_exp,   HAL_ADJUST_DLG),  
    7683                        WMB_ROW(_gap,   _d), 
    77                         WMB_ROW(_auto,  HAL_STORAGE_TYPE_COMBO),  
     84                        WMB_ROW(_auto,  ALLOC_MODE_LAYOUT),  
     85                        WMB_ROW(_auto,  HAL_ADDT_CHECK_MANAGED),  
    7886                        WMB_ROW(_auto,  HAL_CHECK_PAUSED),  
    7987                        WMB_ROW(_auto,  HAL_ADDT_NOTE_TEXT),  
     
    110118                foreach (wstr2alloc_map::value_type i, allocation_type_map_) 
    111119                { 
    112                         ::SendMessage(GetDlgItem(HAL_STORAGE_TYPE_COMBO), CB_ADDSTRING, 0, (LPARAM)i.first.c_str()); 
     120                        ::SendMessage(GetDlgItem(HAL_ADDT_ALLOC_COMBO), CB_ADDSTRING, 0, (LPARAM)i.first.c_str()); 
    113121                } 
    114                 ::SendMessage(GetDlgItem(HAL_STORAGE_TYPE_COMBO), CB_SELECTSTRING, 0, (LPARAM)L"Sparse"); 
     122                ::SendMessage(GetDlgItem(HAL_ADDT_ALLOC_COMBO), CB_SELECTSTRING, 0, (LPARAM)L"Sparse"); 
    115123                 
    116124                BOOL retval =  DoAllDataxchange(false); 
     
    157165        WTL::CRect rect_; 
    158166        bool& startPaused_; 
    159         bool& compactStorage_; 
     167        bool& managed_; 
    160168        hal::bit::allocations& allocation_type_; 
    161169 
  • trunk/src/HaliteListView.cpp

    r612 r614  
    2020#define HAL_CUSTOMDRAW_TITLEDATA 1000000000 
    2121 
     22#define HAL_AUTO_MANAGED 1 
     23#define HAL_UNMANAGED 2 
     24 
    2225HaliteListViewCtrl::HaliteListViewCtrl(HaliteWindow& HalWindow) : 
    2326        halWindow_(HalWindow), 
     
    3841        boost::split(names, column_names, boost::is_any_of(L";")); 
    3942         
    40         array<int, NumberOfColumns_s> widths = {100,110,60,60,60,42,45,61,45,45,45,45,45,45,45,45,45,45,45,45,45,45}; 
     43        array<int, NumberOfColumns_s> widths = {100,110,60,60,60,42,45,61,45,45,45,45,45,45,45,45,45,45,45,45,45,30,45}; 
    4144        array<bool, NumberOfColumns_s> visible = {true,true,true,true,true,true,true,true,true,true,true,\ 
    42                 true,true,true,true,true,true,true,true,true,true,true}; 
     45                true,true,true,true,true,true,true,true,true,true,true,true}; 
    4346 
    4447        for (int i=0, e=NumberOfColumns_s; i < e; ++i) 
     
    4851 
    4952 
    50 //      int ret = EnableGroupView(true); 
    51 /*      if (IsGroupViewEnabled()) 
     53        int ret = EnableGroupView(true); 
     54        if (IsGroupViewEnabled()) 
    5255        { 
    5356//              RemoveAllGroups(); 
     
    5558                LVGROUP lvg = { sizeof(LVGROUP) }; 
    5659 
    57                 lvg.mask = LVGF_HEADER|LVGF_GROUPID|LVGF_STATE|LVGF_ALIGN ; 
    58                 lvg.pszHeader = L"Eoin"; 
    59                 lvg.cchHeader = 5; 
    60                 lvg.iGroupId = 1; 
    61                 lvg.state = LVGS_NORMAL; 
    62                 lvg.uAlign = LVGA_HEADER_LEFT; 
     60                lvg.mask = LVGF_HEADER|LVGF_GROUPID ; 
     61                lvg.pszHeader = L"Auto-managed"; 
     62//              lvg.cchHeader = 5; 
     63                lvg.iGroupId = HAL_AUTO_MANAGED; 
     64//              lvg.state = LVGS_NORMAL; 
     65//              lvg.uAlign = LVGA_HEADER_LEFT; 
    6366 
    6467                int grp = InsertGroup(-1, &lvg); 
     68 
     69                lvg.mask = LVGF_HEADER|LVGF_GROUPID ; 
     70                lvg.pszHeader = L"Unmanaged"; 
     71//              lvg.cchHeader = 5; 
     72                lvg.iGroupId = HAL_UNMANAGED; 
     73//              lvg.state = LVGS_NORMAL; 
     74//              lvg.uAlign = LVGA_HEADER_LEFT; 
     75 
     76                grp = InsertGroup(-1, &lvg); 
    6577//              MoveItemToGroup(1, 1); 
    6678        } 
    67 */ 
     79 
    6880        SafeLoadFromIni(); 
    6981         
     
    89101        SetColumnSortType(19, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::StartTime()); 
    90102        SetColumnSortType(20, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::FinishTime()); 
    91         SetColumnSortType(21, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::QueuePosition()); 
     103        SetColumnSortType(21, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::Managed()); 
     104        SetColumnSortType(22, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::QueuePosition()); 
    92105 
    93106         
     
    135148        if (lock)  
    136149        { 
    137          
    138  
     150                if (GetItemCount() > 0) 
     151                { 
     152                        LVITEM lvItem = { 0 }; 
     153                        lvItem.mask = LVIF_TEXT|LVIF_GROUPID|LVIF_COLUMNS; 
     154                        lvItem.iItem = 0; 
     155                        lvItem.iSubItem = 0; 
     156 
     157                        hal::win_c_str<std::wstring> str(2048); 
     158 
     159                        lvItem.pszText = str; 
     160                        lvItem.cchTextMax = str.size(); 
     161 
     162                        GetItem(&lvItem); 
     163                        DeleteItem(lvItem.iItem); 
     164 
     165                        lvItem.iItem = GetItemCount(); 
     166                        InsertItem(&lvItem); 
     167                } 
    139168 
    140169        foreach (const hal::torrent_details_ptr td, tD.torrents())  
    141170        { 
     171 
    142172                LV_FINDINFO findInfo;  
    143173                findInfo.flags = LVFI_STRING; 
     
    147177                if (itemPos < 0) 
    148178                { 
    149 /*                      LVITEM lvItem = { 0 }; 
    150                         lvItem.mask = LVIF_TEXT|LVIF_GROUPID; 
     179                        LVITEM lvItem = { 0 }; 
     180                        lvItem.mask = LVIF_TEXT|LVIF_GROUPID|LVIF_COLUMNS; 
    151181                        lvItem.iItem = 0; 
    152182                        lvItem.iSubItem = 0; 
    153183                        lvItem.pszText = (LPTSTR)td->name().c_str(); 
    154                         lvItem.iGroupId = 0; 
     184 
     185                        if (td->managed()) 
     186                                lvItem.iGroupId = HAL_AUTO_MANAGED; 
     187                        else 
     188                                lvItem.iGroupId = HAL_UNMANAGED; 
    155189 
    156190                        lvItem.mask |= LVIF_IMAGE; 
    157191                        lvItem.iImage = 0; 
    158192 
    159                         itemPos =  InsertItem(&lvItem); 
    160 */ 
    161                         AddItem(0, 0, td->name().c_str(), 0); 
     193                        itemPos = InsertItem(&lvItem); 
     194 
     195                //      AddItem(0, 0, td->name().c_str(), 0); 
    162196                //      MoveItemToGroup(itemPos, 0); 
    163197                } 
     
    167201                        SetItemText(itemPos, i, getColumnAdapter(i)->print(td).c_str()); 
    168202                } 
     203 
     204//              if (td->queue_position() == 0) 
     205//              { 
     206 
     207//              } 
    169208        } 
    170209         
    171210        int iCol = GetSortColumn(); 
    172         if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
    173                 DoSortItems(iCol, IsSortDescending()); 
     211        //if (autoSort() && iCol >= 0 && iCol < m_arrColSortType.GetSize()) 
     212        //      DoSortItems(iCol, IsSortDescending()); 
    174213         
    175214        } 
  • trunk/src/HaliteListView.hpp

    r573 r614  
    328328        }; 
    329329         
     330        struct Managed : public ColAdapter_t 
     331        { 
     332                virtual int compare(tD& l, tD& r) { return hal::compare(l->managed(), r->managed()); }           
     333                virtual std::wstring print(tD& t)  
     334                {  
     335                        if (t->managed()) 
     336                        { 
     337                                return L"Yes";;  
     338                        } 
     339                        else 
     340                        { 
     341                                return L"No";;   
     342                        } 
     343                }                
     344        }; 
     345         
    330346        struct QueuePosition : public ColAdapter_t 
    331347        { 
     
    416432        void OnDetach(); 
    417433         
    418         enum { NumberOfColumns_s = 22 }; 
     434        enum { NumberOfColumns_s = 23 }; 
    419435         
    420436        HaliteWindow& halWindow_; 
  • trunk/src/HaliteWindow.cpp

    r612 r614  
    341341        bool use_move_to = hal::config().use_move_to_; 
    342342        bool startPaused = false; 
    343         bool compactStorage = false; 
     343        bool managed = false; 
    344344        hal::bit::allocations allocation_type = hal::bit::sparse_allocation; 
    345345         
     
    349349        if (hal::config().save_prompt_) 
    350350        { 
    351                 AddTorrentDialog addTorrent(default_save_folder, default_move_folder, use_move_to, startPaused, compactStorage, allocation_type);        
     351                AddTorrentDialog addTorrent(default_save_folder, default_move_folder, use_move_to, startPaused, managed, allocation_type);       
    352352                 
    353353                if (IDOK != addTorrent.DoModal()) 
     
    356356         
    357357        wpath file(lpszPath, boost::filesystem::native);         
    358         hal::bittorrent().add_torrent(file, wpath(default_save_folder), startPaused, allocation_type,  
     358        hal::bittorrent().add_torrent(file, wpath(default_save_folder), startPaused, managed, allocation_type,  
    359359                wpath(default_move_folder), use_move_to); 
    360360 
  • trunk/src/halSession.hpp

    r612 r614  
    711711        void alert_handler(); 
    712712 
    713         void add_torrent(wpath file, wpath saveDirectory, bool startStopped, bit::allocations alloc,  
     713        void add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, bit::allocations alloc,  
    714714                        boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    715715        { 
     
    744744                                TIp.reset(new torrent_internal(file, saveDirectory, alloc)); 
    745745 
     746                        TIp->set_managed(managed); 
    746747                        TIp->setTransferSpeed(bittorrent().defTorrentDownload(), bittorrent().defTorrentUpload()); 
    747748                        TIp->setConnectionLimit(bittorrent().defTorrentMaxConn(), bittorrent().defTorrentMaxUpload()); 
     
    980981                                        i != e; ++i) 
    981982                        { 
    982                                 if ((*i).torrent->state() != torrent_details::torrent_stopped) 
     983                                if ((*i).torrent && (*i).torrent->state() != torrent_details::torrent_stopped) 
    983984                                        ++num_active; 
    984985                        } 
  • trunk/src/halTorrent.cpp

    r612 r614  
    268268} 
    269269 
    270 void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, allocations alloc,  
     270void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc,  
    271271                boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    272272{ 
    273         pimpl->add_torrent(file, saveDirectory, startStopped, alloc, moveToDirectory, useMoveTo); 
     273        pimpl->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo); 
    274274} 
    275275 
  • trunk/src/halTorrent.hpp

    r612 r614  
    319319{ 
    320320public: 
    321         torrent_details(std::wstring n, std::wstring f, std::wstring sd, std::wstring s, std::wstring cT, std::pair<float,float> sp=std::pair<float,float>(0,0), 
    322                         float c=0, float d=0, size_type tWD=0, size_type tW=0, size_type tU=0, size_type tpU=0, size_type tD=0, size_type tpD=0, boost::tuple<size_type, size_type, size_type, size_type> connections = boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0), float r=0,  
    323                         boost::posix_time::time_duration eta=boost::posix_time::seconds(0), boost::posix_time::time_duration uIn=boost::posix_time::seconds(0), 
    324                         boost::posix_time::time_duration actve=boost::posix_time::seconds(0), boost::posix_time::time_duration seding=boost::posix_time::seconds(0), boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(), boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(), int q_p=-1) : 
     321        torrent_details(std::wstring n, std::wstring f,  
     322                        std::wstring sd,  
     323                        std::wstring s,  
     324                        std::wstring cT,  
     325                        std::pair<float,float> sp=std::pair<float,float>(0,0), 
     326                        float c=0,      float d=0,  
     327                        size_type tWD=0, size_type tW=0,  
     328                        size_type tU=0, size_type tpU=0,  
     329                        size_type tD=0, size_type tpD=0,  
     330                        boost::tuple<size_type, size_type, size_type, size_type> connections =  
     331                                boost::tuple<size_type, size_type, size_type, size_type>(0,0,0,0),  
     332                        float r=0,  
     333                        boost::posix_time::time_duration eta=boost::posix_time::seconds(0),  
     334                        boost::posix_time::time_duration uIn=boost::posix_time::seconds(0), 
     335                        boost::posix_time::time_duration actve=boost::posix_time::seconds(0),  
     336                        boost::posix_time::time_duration seding=boost::posix_time::seconds(0),  
     337                        boost::posix_time::ptime srt=boost::posix_time::second_clock::universal_time(),  
     338                        boost::posix_time::ptime fin=boost::posix_time::second_clock::universal_time(),  
     339                        int q_p=-1,  
     340                        bool man=false) : 
    325341                filename_(f), 
    326342                name_(n), 
     
    350366                startTime_(srt), 
    351367                finishTime_(fin), 
    352                 queue_position_(q_p) 
     368                queue_position_(q_p), 
     369                managed_(man) 
    353370        {} 
    354371 
     
    403420 
    404421        int queue_position() const { return queue_position_; } 
     422        bool managed() const { return managed_; } 
    405423         
    406424public: 
     
    438456 
    439457        int queue_position_; 
     458        bool managed_; 
    440459         
    441460private: 
     
    796815        void set_torrent_defaults(const connections& defaults);  
    797816        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory,  
    798                 bool startPaused=false, allocations alloc=hal::bit::sparse_allocation,  
     817                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation,  
    799818                boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false); 
    800819         
  • trunk/src/halTorrentInternal.hpp

    r612 r614  
    332332                totalBase_(0), \ 
    333333                progress_(0), \ 
     334                managed_(false), \ 
    334335                startTime_(boost::posix_time::second_clock::universal_time()), \ 
    335336                in_session_(false), \ 
     
    461462                boost::tuple<size_t, size_t, size_t, size_t> connections = updatePeers();        
    462463 
    463                 return torrent_details_ptr(new torrent_details(name_, filename_, saveDirectory().string(), state, hal::from_utf8(statusMemory_.current_tracker),  
    464                         std::pair<float, float>(statusMemory_.download_payload_rate, statusMemory_.upload_payload_rate), 
    465                         progress_, statusMemory_.distributed_copies, statusMemory_.total_wanted_done, statusMemory_.total_wanted, uploaded_, payloadUploaded_, 
    466                         downloaded_, payloadDownloaded_, connections, ratio_, td, statusMemory_.next_announce, activeDuration_, seedingDuration_, startTime_, finishTime_, queue_position_)); 
     464                return torrent_details_ptr(new torrent_details( 
     465                        name_, filename_,  
     466                        saveDirectory().string(),  
     467                        state,  
     468                        hal::from_utf8(statusMemory_.current_tracker),  
     469                        std::pair<float, float>( 
     470                                statusMemory_.download_payload_rate,  
     471                                statusMemory_.upload_payload_rate), 
     472                        progress_,  
     473                        statusMemory_.distributed_copies,  
     474                        statusMemory_.total_wanted_done,  
     475                        statusMemory_.total_wanted,  
     476                        uploaded_, payloadUploaded_, 
     477                        downloaded_, payloadDownloaded_,  
     478                        connections,  
     479                        ratio_,  
     480                        td,  
     481                        statusMemory_.next_announce,  
     482                        activeDuration_, seedingDuration_,  
     483                        startTime_, finishTime_,  
     484                        queue_position_, 
     485                        get_managed())); 
    467486 
    468487                } 
     
    478497                } 
    479498                 
    480                 return torrent_details_ptr(new torrent_details(name_, filename_, saveDirectory().string(), app().res_wstr(HAL_TORRENT_STOPPED), app().res_wstr(HAL_NA))); 
     499                return torrent_details_ptr(new torrent_details( 
     500                        name_, filename_,  
     501                        saveDirectory().string(),  
     502                        app().res_wstr(HAL_TORRENT_STOPPED),  
     503                        app().res_wstr(HAL_NA))); 
    481504        } 
    482505 
     
    523546        { 
    524547                return ratio_; 
     548        } 
     549 
     550        void set_managed(bool m) 
     551        { 
     552                mutex_t::scoped_lock l(mutex_); 
     553                managed_ = m; 
     554                 
     555                if (in_session()) handle_.auto_managed(managed_); 
     556        } 
     557 
     558        bool get_managed() 
     559        { 
     560                if (in_session()) 
     561                { 
     562                        assert(managed_ == handle_.is_auto_managed()); 
     563                } 
     564 
     565                return managed_; 
    525566        } 
    526567         
     
    556597                        p.paused = paused; 
    557598                        p.duplicate_is_error = false; 
    558                         p.auto_managed = false; 
     599                        p.auto_managed = managed_; 
    559600 
    560601                        handle_ = the_session_->add_torrent(p);          
     
    933974                        ar & make_nvp("active_duration", activeDuration_); 
    934975                        ar & make_nvp("seeding_duration", seedingDuration_); 
     976                        ar & make_nvp("managed", managed_); 
    935977                                         
    936978                }  
     
    13501392        int queue_position_; 
    13511393        bool compactStorage_; 
     1394        bool managed_; 
    13521395        bit::allocations allocation_; 
    13531396}; 
Note: See TracChangeset for help on using the changeset viewer.