Changeset 508


Ignore:
Timestamp:
07/21/08 01:12:48 (11 years ago)
Author:
Eoin
Message:

Major SortList? de-blobbing.

Location:
trunk/src
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteDialog.hpp

    r507 r508  
    9292                DialogListView() : 
    9393                        iniClass("listviews/dialog", "DialogPeersList") 
    94                 {                                        
     94                {} 
     95                 
     96                void saveSettings() 
     97                { 
     98                        GetListViewDetails(); 
     99                        save_to_ini(); 
     100                } 
     101                 
     102                bool SubclassWindow(HWND hwnd) 
     103                { 
     104                        if(!parentClass::SubclassWindow(hwnd)) 
     105                                return false; 
     106                                 
     107                        WTL::CMenuHandle menu; 
     108                        BOOL menu_created = menu.LoadMenu(LISTVIEW_ID_MENU); 
     109                        InitialSetup(menu);      
     110 
    95111                        std::vector<wstring> names;      
    96112                        wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
     
    102118                        array<int, 6> order = {0,1,2,3,4,5}; 
    103119                        array<bool, 6> visible = {true,true,true,true,true,true}; 
     120 
     121                        for (int i=0, e=6; i < e; ++i) 
     122                        { 
     123                                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     124                        }        
    104125                         
    105                         SetDefaults(names, widths, order, visible); 
    106126                        load_from_ini(); 
    107                 } 
    108                  
    109                 void saveSettings() 
    110                 { 
    111                         GetListViewDetails(); 
    112                         save_to_ini(); 
    113                 } 
    114                  
    115                 bool SubclassWindow(HWND hwnd) 
    116                 { 
    117                         if(!parentClass::SubclassWindow(hwnd)) 
    118                                 return false; 
    119                                  
    120                         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER); 
    121                         SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
    122                          
    123                         ApplyDetails(); 
    124127                         
    125128                        SetColumnSortType(2, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedDown()); 
  • trunk/src/HaliteListView.cpp

    r507 r508  
    2323{                
    2424        HalWindow.connectUiUpdate(bind(&HaliteListViewCtrl::uiUpdate, this, _1)); 
    25          
     25} 
     26 
     27void HaliteListViewCtrl::OnShowWindow(UINT, INT) 
     28{ 
     29        WTL::CMenuHandle menu; 
     30        BOOL menu_created = menu.LoadMenu(HAL_LISTVIEW_MENU); 
     31        InitialSetup(menu);      
     32 
    2633        std::vector<wstring> names;      
    2734        wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
     
    3340        array<bool, NumberOfColumns_s> visible = {true,true,true,true,true,true,true,true,true,true,true,\ 
    3441                true,true,true,true,true,true,true,true,true,true}; 
    35          
    36         SetDefaults(names, widths, order, visible); 
     42 
     43        for (int i=0, e=NumberOfColumns_s; i < e; ++i) 
     44        { 
     45                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     46        }        
     47 
    3748        SafeLoadFromIni(); 
    38 } 
    39  
    40 void HaliteListViewCtrl::OnShowWindow(UINT, INT) 
    41 { 
    42         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER); 
    43         SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
    44          
    45         ApplyDetails(); 
    4649         
    4750        SetColumnSortType(0, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::Name()); 
  • trunk/src/HaliteSortListViewCtrl.hpp

    r503 r508  
    9595                        bool visible = listView_.OnNameChecked(wID-COL_MENU_NAMES); 
    9696 
    97                         MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
     97                /*      MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
    9898                 
    9999                        minfo.fMask = MIIM_STATE; 
    100100                        minfo.fState = visible ? MFS_CHECKED : MFS_UNCHECKED; 
    101101                 
    102                         menu_.SetMenuItemInfo(wID, false, &minfo); 
     102                        menu_.SetMenuItemInfo(wID, false, &minfo);*/ 
    103103 
    104104                        return 0; 
     
    186186        }                
    187187         
    188         template<typename N, typename W, typename O, typename P> 
     188/*      template<typename N, typename W, typename O, typename P> 
    189189        void SetDefaults(N nameList, W widthList, O orderList, P visibleList, bool autoSort=false) 
    190190        { 
     
    196196                autoSort_ = autoSort; 
    197197        } 
    198  
     198*/ 
    199199        void SafeLoadFromIni() 
    200200        { 
     
    218218                }                
    219219        } 
    220          
     220/*       
    221221        void ApplyDetails() 
    222222        { 
     
    282282                        SetSortColumn(sortCol_); 
    283283        } 
     284*/ 
     285        void InitialSetup(WTL::CMenuHandle menu=WTL::CMenuHandle()) 
     286        { 
     287                SetExtendedListViewStyle(LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER); 
     288                SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS,SORTLV_USESHELLBITMAPS); 
     289 
     290                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
     291                 
     292                if (!menu) 
     293                { 
     294                        menu_.CreatePopupMenu(); 
     295                } 
     296                else 
     297                {                
     298                        menu_.Attach(menu.GetSubMenu(0)); 
     299 
     300                        minfo.fMask = MIIM_SUBMENU; 
     301                        minfo.fType = MFT_SEPARATOR; 
     302                         
     303                        menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo);            
     304                } 
     305 
     306                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE; 
     307                minfo.fType = MFT_STRING; 
     308                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
     309                minfo.wID = ID_LVM_AUTOSORT; 
     310                 
     311                std::wstring autoarrange = hal::app().res_wstr(HAL_AUTOSORT); 
     312                minfo.dwTypeData = (LPWSTR)autoarrange.c_str(); 
     313                 
     314                menu_.InsertMenuItem(menu_.GetMenuItemCount(), true, &minfo); 
     315 
     316                header_.SubclassWindow(this->GetHeader()); 
     317                header_.ModifyStyle(0, HDS_DRAGDROP|HDS_FULLDRAG); 
     318                if (header_.Menu().IsNull())  
     319                        header_.Menu().CreatePopupMenu(); 
     320        } 
    284321         
    285322        void GetListViewDetails() 
     
    341378                        listVisible_[i] = false; 
    342379                } 
     380                 
     381                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)};     
     382                minfo.fMask = MIIM_STATE; 
     383                minfo.fState = listVisible_[i] ? MFS_CHECKED : MFS_UNCHECKED;    
     384                header_.Menu().SetMenuItemInfo(CHaliteHeaderCtrl::COL_MENU_NAMES+i, false, &minfo); 
    343385         
    344386                InvalidateRect(NULL, true); 
     
    384426                return 0; 
    385427        } 
    386          
     428 
     429        int AddColumn(LPCTSTR strItem, int nItem, bool visible, int width=-1) 
     430        { 
     431                return AddColumn(strItem, nItem, -1, 
     432                        LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM, 
     433                        LVCFMT_LEFT, visible, width); 
     434        } 
     435 
     436        int AddColumn(LPCTSTR strItem, int nItem, int nSubItem = -1, 
     437                        int nMask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM, 
     438                        int nFmt = LVCFMT_LEFT, bool visible=true, int width=-1) 
     439        { 
     440 
     441                int i = parentClass::AddColumn(strItem, nItem, nSubItem, nMask, nFmt); 
     442 
     443                if (i == -1) return i; 
     444 
     445                if (width != -1) SetColumnWidth(i, width); 
     446 
     447                if (header_.Menu().IsNull())  
     448                        header_.Menu().CreatePopupMenu(); 
     449 
     450                WTL::CMenuHandle menu = header_.Menu(); 
     451 
     452                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
     453                minfo.fMask = MIIM_STRING|MIIM_ID|MIIM_FTYPE|MIIM_STATE; 
     454                minfo.fType = MFT_STRING; 
     455                minfo.dwTypeData = (LPTSTR)strItem; 
     456                minfo.wID = CHaliteHeaderCtrl::COL_MENU_NAMES+i; 
     457 
     458                if (visible) 
     459                        minfo.fState = MFS_CHECKED; 
     460                else 
     461                { 
     462                        minfo.fState = MFS_UNCHECKED; 
     463                        SetColumnWidth(i, 0); 
     464                } 
     465 
     466                int w = GetColumnWidth(i); 
     467 
     468                listNames_.push_back(strItem); 
     469                listVisible_.push_back(visible); 
     470                listWidths_.push_back(w); 
     471                listOrder_.push_back(i); 
     472 
     473                menu.InsertMenuItem(menu.GetMenuItemCount(), false, &minfo); 
     474                return i; 
     475        } 
     476 
    387477        void SetColumnSortType(int iCol, WORD wType, ColumnAdapter* colAdapter=NULL) 
    388478        { 
     
    392482                        regColumnAdapter(iCol, colAdapter); 
    393483        } 
    394          
     484 
     485        void SetColumnOrderState() 
     486        { 
     487                while ((int)listOrder_.size() < header_.GetItemCount()) 
     488                        listOrder_.push_back(header_.GetItemCount()); 
     489 
     490                GetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
     491        } 
     492 
     493        void SetSortState() 
     494        { 
     495                MENUITEMINFO minfo = {sizeof(MENUITEMINFO)}; 
     496                 
     497                minfo.fMask = MIIM_STATE; 
     498                minfo.fState = autoSort_ ? MFS_CHECKED : MFS_UNCHECKED; 
     499                 
     500                menu_.SetMenuItemInfo(ID_LVM_AUTOSORT, false, &minfo); 
     501 
     502                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize()) 
     503                        SetSortColumn(sortCol_); 
     504        } 
     505 
    395506        friend class boost::serialization::access; 
     507        template<class Archive> 
     508    void save(Archive & ar, const unsigned int version) const 
     509    { 
     510                for (size_t i=0; i<listWidths_.size(); ++i) 
     511                { 
     512                        if (listVisible_[i]) 
     513                                listWidths_[i] = GetColumnWidth(i); 
     514                } 
     515 
     516                GetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
     517                sortCol_ = GetSortColumn(); 
     518                descending_ = IsSortDescending();        
     519 
     520                using boost::serialization::make_nvp; 
     521 
     522                ar & make_nvp("width", listWidths_); 
     523                ar & make_nvp("order", listOrder_); 
     524                ar & make_nvp("visible", listVisible_); 
     525                ar & make_nvp("autoSort", autoSort_); 
     526 
     527                ar & make_nvp("descending", descending_); 
     528                ar & make_nvp("sortCol", sortCol_); 
     529    } 
     530 
    396531    template<class Archive> 
    397     void serialize(Archive & ar, const unsigned int version) 
     532    void load(Archive & ar, const unsigned int version) 
    398533    { 
    399534                using boost::serialization::make_nvp; 
    400                 if (version >= 1) 
    401                 { 
    402                         ar & make_nvp("width", listWidths_); 
    403                         ar & make_nvp("order", listOrder_); 
    404                         ar & make_nvp("visible", listVisible_); 
    405                         ar & make_nvp("autoSort", autoSort_); 
    406                 } 
    407                 if (version >= 2) 
    408                 { 
    409                         ar & make_nvp("descending", descending_); 
    410                         ar & make_nvp("sortCol", sortCol_); 
    411                 } 
     535 
     536                ar & make_nvp("width", listWidths_); 
     537                ar & make_nvp("order", listOrder_); 
     538                ar & make_nvp("visible", listVisible_); 
     539                ar & make_nvp("autoSort", autoSort_); 
     540 
     541                ar & make_nvp("descending", descending_); 
     542                ar & make_nvp("sortCol", sortCol_); 
     543                 
     544                SetColumnOrderArray(listOrder_.size(), &listOrder_[0]); 
     545 
     546                m_bSortDescending = descending_; 
     547                if (sortCol_ >= 0 && sortCol_ < m_arrColSortType.GetSize()) 
     548                        SetSortColumn(sortCol_); 
     549 
     550                for (size_t i=0; i<listWidths_.size(); ++i) 
     551                { 
     552                        SetColumnWidth(i, listWidths_[i]); 
     553                        if (!listVisible_[i]) 
     554                        { 
     555                                listVisible_[i] = true; 
     556                                OnNameChecked(i); 
     557                        } 
     558                } 
     559 
     560                SetColumnOrderState(); 
     561                SetSortState(); 
    412562    } 
     563 
     564    BOOST_SERIALIZATION_SPLIT_MEMBER() 
    413565 
    414566        const SelectionManager& manager() { return manager_; } 
     
    503655        CHaliteHeaderCtrl header_;       
    504656         
    505         std::vector<wstring> listNames_; 
    506         std::vector<int> listWidths_; 
    507         std::vector<int> listOrder_; 
    508         std::vector<bool> listVisible_; 
    509         bool autoSort_; 
    510         bool descending_; 
    511         int sortCol_; 
     657        mutable std::vector<wstring> listNames_; 
     658        mutable std::vector<int> listWidths_; 
     659        mutable std::vector<int> listOrder_; 
     660        mutable std::vector<bool> listVisible_; 
     661        mutable bool autoSort_; 
     662        mutable bool descending_; 
     663        mutable int sortCol_; 
    512664         
    513665        mutable int update_lock_; 
  • trunk/src/NewTorrentDialog.cpp

    r495 r508  
    6161void FilesListViewCtrl::OnAttach() 
    6262{ 
    63         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    64         SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
     63        InitialSetup();          
     64 
     65        std::vector<wstring> names;      
     66        wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
     67 
     68        // "Tracker;Tier" 
     69        boost::split(names, column_names, boost::is_any_of(L";")); 
    6570         
    66         ApplyDetails(); 
     71        array<int, 3> widths = {50,287,50}; 
     72        array<int, 3> order = {0,1,2}; 
     73        array<bool, 3> visible = {true,true,true}; 
     74         
     75        for (int i=0, e=3; i < e; ++i) 
     76        { 
     77                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     78        }        
     79 
     80        load_from_ini(); 
    6781         
    6882        SetColumnSortType(0, WTL::LVCOLSORT_TEXTNOCASE); 
  • trunk/src/NewTorrentDialog.hpp

    r507 r508  
    6767        FilesListViewCtrl() : 
    6868                iniClass("listviews/new_files", "NewFilesListView") 
    69         { 
    70                 std::vector<wstring> names;      
    71                 wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
    72  
    73                 // "Tracker;Tier" 
    74                 boost::split(names, column_names, boost::is_any_of(L";")); 
    75                  
    76                 array<int, 3> widths = {50,287,50}; 
    77                 array<int, 3> order = {0,1,2}; 
    78                 array<bool, 3> visible = {true,true,true}; 
    79                  
    80                 SetDefaults(names, widths, order, visible, true); 
    81                 load_from_ini(); 
    82         } 
     69        {} 
    8370 
    8471        BEGIN_MSG_MAP_EX(FilesListViewCtrl) 
  • trunk/src/NewTorrentPeersLV.cpp

    r492 r508  
    1212 
    1313void NewTorrent_PeersListViewCtrl::OnAttach() 
    14 { 
    15         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    16         SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
     14{        
     15        WTL::CMenuHandle menu; 
     16        BOOL menu_created = menu.LoadMenu(HAL_GENERIC_ADD_LV_MENU); 
     17        InitialSetup(menu);      
     18 
     19        std::vector<wstring> names;      
     20        wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
     21 
     22        // "Tracker;Tier" 
     23        boost::split(names, column_names, boost::is_any_of(L";")); 
    1724         
    18         ApplyDetails(); 
     25        array<int, 3> widths = {287,50,50}; 
     26        array<int, 3> order = {0,1,2}; 
     27        array<bool, 3> visible = {true,true,true}; 
     28         
     29        for (int i=0, e=3; i < e; ++i) 
     30        { 
     31                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     32        }        
     33 
     34        load_from_ini();         
    1935         
    2036        SetColumnSortType(1, WTL::LVCOLSORT_LONG); 
  • trunk/src/NewTorrentPeersLV.hpp

    r507 r508  
    4747        NewTorrent_PeersListViewCtrl() : 
    4848                iniClass("listviews/NewTorrentPeers", "NewPeersListView") 
    49         { 
    50                 std::vector<wstring> names;      
    51                 wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
    52  
    53                 // "Tracker;Tier" 
    54                 boost::split(names, column_names, boost::is_any_of(L";")); 
    55                  
    56                 array<int, 3> widths = {287,50,50}; 
    57                 array<int, 3> order = {0,1,2}; 
    58                 array<bool, 3> visible = {true,true,true}; 
    59                  
    60                 SetDefaults(names, widths, order, visible, true); 
    61                 load_from_ini(); 
    62         } 
     49        {} 
    6350 
    6451        BEGIN_MSG_MAP_EX(thisClass) 
  • trunk/src/NewTorrentTrackerLV.cpp

    r507 r508  
    1414void NewTorrent_TrackerListViewCtrl::OnAttach() 
    1515{ 
    16         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    17         SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
     16        WTL::CMenuHandle menu; 
     17        BOOL menu_created = menu.LoadMenu(LISTVIEW_ID_MENU); 
     18        InitialSetup(menu); 
     19 
     20        std::vector<wstring> names;      
     21        wstring column_names = hal::app().res_wstr(HAL_TRACKER_LISTVIEW_COLUMNS); 
     22 
     23        // "Tracker;Tier" 
     24        boost::split(names, column_names, boost::is_any_of(L";")); 
    1825         
    19         ApplyDetails(); 
     26        array<int, 2> widths = {287,50}; 
     27        array<int, 2> order = {0,1}; 
     28        array<bool, 2> visible = {true,true};    
     29         
     30        for (int i=0, e=2; i < e; ++i) 
     31        { 
     32                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     33        }        
     34         
     35        load_from_ini(); 
    2036         
    2137        SetColumnSortType(1, WTL::LVCOLSORT_LONG); 
  • trunk/src/NewTorrentTrackerLV.hpp

    r507 r508  
    4646        NewTorrent_TrackerListViewCtrl() : 
    4747                iniClass("listviews/NewTorrent", "NewTorrentListView") 
    48         { 
    49                 std::vector<wstring> names;      
    50                 wstring column_names = hal::app().res_wstr(HAL_TRACKER_LISTVIEW_COLUMNS); 
    51  
    52                 // "Tracker;Tier" 
    53                 boost::split(names, column_names, boost::is_any_of(L";")); 
    54                  
    55                 array<int, 2> widths = {287,50}; 
    56                 array<int, 2> order = {0,1}; 
    57                 array<bool, 2> visible = {true,true}; 
    58                  
    59                 SetDefaults(names, widths, order, visible, true); 
    60                 load_from_ini(); 
    61         } 
     48        {} 
    6249 
    6350        BEGIN_MSG_MAP_EX(TrackerListViewCtrl) 
  • trunk/src/advtabs/Debug.hpp

    r495 r508  
    9191        LogListViewCtrl() : 
    9292                iniClass("listviews/eventLog", "LogListView") 
    93         { 
    94                 std::vector<wstring> names;      
    95                 wstring column_names = hal::app().res_wstr(HAL_DEBUG_LISTVIEW_COLUMNS); 
    96  
    97                 // "Time;Message;Severity" 
    98                 boost::split(names, column_names, boost::is_any_of(L";")); 
    99                  
    100                 array<int, 3> widths = {67,419,69}; 
    101                 array<int, 3> order = {0,1,2}; 
    102                 array<bool, 3> visible = {true,true,true}; 
    103                  
    104                 SetDefaults(names, widths, order, visible, true); 
    105                  
    106                 load_from_ini(); 
    107         } 
     93        {} 
    10894         
    10995        ~LogListViewCtrl() 
     
    180166                hal::mutex_t::scoped_lock l(mutex_); 
    181167         
    182                 SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    183                 SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
    184                  
    185                 ApplyDetails(); 
     168                InitialSetup();          
     169 
     170                std::vector<wstring> names;      
     171                wstring column_names = hal::app().res_wstr(HAL_DEBUG_LISTVIEW_COLUMNS); 
     172 
     173                // "Time;Message;Severity" 
     174                boost::split(names, column_names, boost::is_any_of(L";")); 
     175                 
     176                array<int, 3> widths = {67,419,69}; 
     177                array<int, 3> order = {0,1,2}; 
     178                array<bool, 3> visible = {true,true,true}; 
     179 
     180                for (int i=0, e=3; i < e; ++i) 
     181                { 
     182                        AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     183                }        
     184         
     185                load_from_ini(); 
    186186                 
    187187                conn_ = hal::event_log.attach(bind(&LogListViewCtrl::operator(), this, _1)); 
  • trunk/src/advtabs/Files.cpp

    r507 r508  
    1818FileListView::FileListView() : 
    1919        iniClass("listviews/advFiles", "FileListView") 
    20 {                                        
     20{} 
     21 
     22HWND FileListView::Create(HWND hWndParent, ATL::_U_RECT rect, LPCTSTR szWindowName, 
     23        DWORD dwStyle, DWORD dwExStyle, 
     24        ATL::_U_MENUorID MenuOrID, LPVOID lpCreateParam) 
     25{ 
     26        HWND hwnd = listClass::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); 
     27        assert(hwnd); 
     28         
     29        WTL::CMenuHandle menu; 
     30        BOOL menu_created = menu.LoadMenu(LISTVIEW_ID_MENU); 
     31        InitialSetup(menu);      
     32 
    2133        std::vector<wstring> names;      
    2234        wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
     
    2739        array<int, 5> order = {0,1,2,3,4}; 
    2840        array<bool, 5> visible = {true,true,true,true,true}; 
    29          
    30         SetDefaults(names, widths, order, visible, true); 
     41 
     42        for (int i=0, e=5; i < e; ++i) 
     43        { 
     44                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     45        }        
     46 
    3147        load_from_ini(); 
    32 } 
    33  
    34 HWND FileListView::Create(HWND hWndParent, ATL::_U_RECT rect, LPCTSTR szWindowName, 
    35         DWORD dwStyle, DWORD dwExStyle, 
    36         ATL::_U_MENUorID MenuOrID, LPVOID lpCreateParam) 
    37 { 
    38         HWND hwnd = listClass::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); 
    39         assert(hwnd); 
    40          
    41         ApplyDetails(); 
    42          
    43         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_HEADERDRAGDROP|LVS_EX_DOUBLEBUFFER); 
    4448         
    4549        SetColumnSortType(2, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::Size()); 
  • trunk/src/advtabs/Files.hpp

    r507 r508  
    174174                DWORD dwStyle = 0, DWORD dwExStyle = 0, 
    175175                ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL); 
    176          
    177         bool SubclassWindow(HWND hwnd) 
    178         { 
    179                 if(!listClass::SubclassWindow(hwnd)) 
    180                         return false; 
    181                  
    182                 ApplyDetails();          
    183                 return true; 
    184         } 
    185176         
    186177        void OnDestroy() 
  • trunk/src/advtabs/Peers.hpp

    r507 r508  
    7171        thisClass() : 
    7272                iniClass("listviews/advPeers", "PeerListView") 
    73         {                                        
    74                 std::vector<wstring> names;      
    75                 wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
    76  
    77                 // "Peer;Country;Download;Upload;Type;Client,Status" 
    78                 boost::split(names, column_names, boost::is_any_of(L";")); 
    79                  
    80                 array<int, 7> widths = {100,20,70,70,70,100,200}; 
    81                 array<int, 7> order = {0,1,2,3,4,5,6}; 
    82                 array<bool, 7> visible = {true,true,true,true,true,true,true}; 
    83                  
    84                 SetDefaults(names, widths, order, visible, true); 
    85                 load_from_ini(); 
    86         } 
     73        {} 
    8774         
    8875        void saveSettings() 
     
    9683                if(!listClass::SubclassWindow(hwnd)) 
    9784                        return false; 
     85 
     86                InitialSetup();  
     87                 
     88                std::vector<wstring> names;      
     89                wstring column_names = hal::app().res_wstr(LISTVIEW_ID_COLUMNNAMES); 
     90 
     91                // "Peer;Country;Download;Upload;Type;Client,Status" 
     92                boost::split(names, column_names, boost::is_any_of(L";")); 
     93                 
     94                array<int, 7> widths = {100,20,70,70,70,100,200}; 
     95                array<int, 7> order = {0,1,2,3,4,5,6}; 
     96                array<bool, 7> visible = {true,true,true,true,true,true,true}; 
     97 
     98                for (int i=0, e=7; i < e; ++i) 
     99                { 
     100                        AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     101                }        
    98102                                         
    99                 ApplyDetails(); 
     103                load_from_ini(); 
    100104                 
    101105                SetColumnSortType(2, WTL::LVCOLSORT_CUSTOM, new ColumnAdapters::SpeedDown()); 
  • trunk/src/advtabs/TrackerListView.cpp

    r507 r508  
    1414void TrackerListViewCtrl::OnAttach() 
    1515{ 
    16         SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    17         SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
     16        WTL::CMenuHandle menu; 
     17        BOOL menu_created = menu.LoadMenu(LISTVIEW_ID_MENU); 
     18        InitialSetup(menu);      
     19 
     20        std::vector<wstring> names;      
     21        wstring column_names = hal::app().res_wstr(HAL_TRACKER_LISTVIEW_COLUMNS); 
     22 
     23        // "Tracker;Tier" 
     24        boost::split(names, column_names, boost::is_any_of(L";")); 
    1825         
    19         ApplyDetails(); 
     26        array<int, 2> widths = {287,50}; 
     27        array<int, 2> order = {0,1}; 
     28        array<bool, 2> visible = {true,true}; 
     29 
     30        for (int i=0, e=2; i < e; ++i) 
     31        { 
     32                AddColumn(names[i].c_str(), i, visible[i], widths[i]); 
     33        }        
     34 
     35        load_from_ini();         
    2036         
    2137        SetColumnSortType(1, WTL::LVCOLSORT_LONG); 
  • trunk/src/advtabs/TrackerListView.hpp

    r507 r508  
    4444        TrackerListViewCtrl(boost::filesystem::path location, std::string name) : 
    4545                iniClass(location, name) 
    46         { 
    47                 std::vector<wstring> names;      
    48                 wstring column_names = hal::app().res_wstr(HAL_TRACKER_LISTVIEW_COLUMNS); 
    49  
    50                 // "Tracker;Tier" 
    51                 boost::split(names, column_names, boost::is_any_of(L";")); 
    52                  
    53                 array<int, 2> widths = {287,50}; 
    54                 array<int, 2> order = {0,1}; 
    55                 array<bool, 2> visible = {true,true}; 
    56                  
    57                 SetDefaults(names, widths, order, visible, true); 
    58                 load_from_ini(); 
    59         } 
     46        {} 
    6047 
    6148        BEGIN_MSG_MAP_EX(TrackerListViewCtrl) 
  • trunk/src/halSession.cpp

    r503 r508  
    279279} 
    280280 
     281bool bit_impl::create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn) 
     282{                
     283try 
     284{ 
     285        libt::file_storage fs; 
     286        libt::file_pool f_pool; 
     287 
     288 
     289        HAL_DEV_MSG(L"Files"); 
     290        for (file_size_pairs_t::const_iterator i = params.file_size_pairs.begin(), e = params.file_size_pairs.end(); 
     291                        i != e; ++i) 
     292        { 
     293                HAL_DEV_MSG(wformat(L"file path: %1%, size: %2%") % (*i).first % (*i).second); 
     294                f_pool->add_file(to_utf8((*i).first.string()), (*i).second); 
     295        } 
     296 
     297        int piece_size = params.piece_size; 
     298        HAL_DEV_MSG(wformat(L"piece size: %1%") % piece_size); 
     299         
     300        libt::create_torrent t(fs, piece_size); 
     301         
     302        boost::scoped_ptr<libt::storage_interface> store( 
     303                libt::default_storage_constructor(t_info, to_utf8(params.root_path.string()), 
     304                        f_pool)); 
     305 
     306        HAL_DEV_MSG(L"Trackers"); 
     307        for (tracker_details_t::const_iterator i = params.trackers.begin(), e = params.trackers.end(); 
     308                        i != e; ++i) 
     309        { 
     310                HAL_DEV_MSG(wformat(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier); 
     311                t_info->add_tracker(to_utf8((*i).url), (*i).tier); 
     312        } 
     313 
     314        HAL_DEV_MSG(L"Web Seeds"); 
     315        for (web_seed_details_t::const_iterator i = params.web_seeds.begin(), e = params.web_seeds.end(); 
     316                        i != e; ++i) 
     317        { 
     318                HAL_DEV_MSG(wformat(L"URL: %1%") % (*i).url); 
     319                t_info->add_url_seed(to_utf8((*i).url)); 
     320        } 
     321 
     322        HAL_DEV_MSG(L"DHT Nodes"); 
     323        for (dht_node_details_t::const_iterator i = params.dht_nodes.begin(), e = params.dht_nodes.end(); 
     324                        i != e; ++i) 
     325        { 
     326                HAL_DEV_MSG(wformat(L"URL: %1%, port: %2%") % (*i).url % (*i).port); 
     327                t_info->add_node(hal::make_pair(to_utf8((*i).url), (*i).port)); 
     328        } 
     329 
     330        // calculate the hash for all pieces 
     331        int num = t_info->num_pieces(); 
     332        std::vector<char> piece_buf(piece_size); 
     333 
     334        for (int i = 0; i < num; ++i) 
     335        { 
     336                store->read(&piece_buf[0], i, 0, t_info->piece_size(i)); 
     337 
     338                libt::hasher h(&piece_buf[0], t_info->piece_size(i)); 
     339                t_info->set_hash(i, h.final()); 
     340 
     341                if (fn(100*i / num, hal::app().res_wstr(HAL_NEWT_HASHING_PIECES))) 
     342                { 
     343                        // User canceled torrent creation. 
     344 
     345                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     346                                new hal::EventMsg(hal::app().res_wstr(HAL_NEWT_CREATION_CANCELED), hal::event_logger::info))); 
     347 
     348                        return true; 
     349                } 
     350        } 
     351 
     352        t_info->set_creator(to_utf8(params.creator).c_str()); 
     353        t_info->set_comment(to_utf8(params.comment).c_str()); 
     354         
     355        t_info->set_priv(params.private_torrent); 
     356 
     357        // create the torrent and print it to out 
     358        libt::entry e = t_info->create_torrent(); 
     359        halencode(out_file, e); 
     360        } 
     361        catch(const std::exception& e) 
     362        { 
     363                event_log.post(shared_ptr<EventDetail>( 
     364                        new EventStdException(event_logger::fatal, e, L"create_torrent"))); 
     365        }        
     366 
     367        return false; 
     368} 
     369 
     370 
    281371void bit_impl::start_alert_handler() 
    282372{ 
  • trunk/src/halSession.hpp

    r507 r508  
    906906 
    907907private: 
    908  
    909         bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn) 
    910         {                
    911 /*       
    912         try 
    913         { 
    914                 libt::file_storage fs; 
    915                 libt::file_pool f_pool; 
    916  
    917  
    918                 HAL_DEV_MSG(L"Files"); 
    919                 for (file_size_pairs_t::const_iterator i = params.file_size_pairs.begin(), e = params.file_size_pairs.end(); 
    920                                 i != e; ++i) 
    921                 { 
    922                         HAL_DEV_MSG(wformat(L"file path: %1%, size: %2%") % (*i).first % (*i).second); 
    923                         f_pool->add_file(to_utf8((*i).first.string()), (*i).second); 
    924                 } 
    925  
    926                 int piece_size = params.piece_size; 
    927                 HAL_DEV_MSG(wformat(L"piece size: %1%") % piece_size); 
    928                  
    929                 libt::create_torrent t(fs, piece_size); 
    930                  
    931                 boost::scoped_ptr<libt::storage_interface> store( 
    932                         libt::default_storage_constructor(t_info, to_utf8(params.root_path.string()), 
    933                                 f_pool)); 
    934  
    935                 HAL_DEV_MSG(L"Trackers"); 
    936                 for (tracker_details_t::const_iterator i = params.trackers.begin(), e = params.trackers.end(); 
    937                                 i != e; ++i) 
    938                 { 
    939                         HAL_DEV_MSG(wformat(L"URL: %1%, Tier: %2%") % (*i).url % (*i).tier); 
    940                         t_info->add_tracker(to_utf8((*i).url), (*i).tier); 
    941                 } 
    942  
    943                 HAL_DEV_MSG(L"Web Seeds"); 
    944                 for (web_seed_details_t::const_iterator i = params.web_seeds.begin(), e = params.web_seeds.end(); 
    945                                 i != e; ++i) 
    946                 { 
    947                         HAL_DEV_MSG(wformat(L"URL: %1%") % (*i).url); 
    948                         t_info->add_url_seed(to_utf8((*i).url)); 
    949                 } 
    950  
    951                 HAL_DEV_MSG(L"DHT Nodes"); 
    952                 for (dht_node_details_t::const_iterator i = params.dht_nodes.begin(), e = params.dht_nodes.end(); 
    953                                 i != e; ++i) 
    954                 { 
    955                         HAL_DEV_MSG(wformat(L"URL: %1%, port: %2%") % (*i).url % (*i).port); 
    956                         t_info->add_node(hal::make_pair(to_utf8((*i).url), (*i).port)); 
    957                 } 
    958  
    959                 // calculate the hash for all pieces 
    960                 int num = t_info->num_pieces(); 
    961                 std::vector<char> piece_buf(piece_size); 
    962  
    963                 for (int i = 0; i < num; ++i) 
    964                 { 
    965                         store->read(&piece_buf[0], i, 0, t_info->piece_size(i)); 
    966  
    967                         libt::hasher h(&piece_buf[0], t_info->piece_size(i)); 
    968                         t_info->set_hash(i, h.final()); 
    969  
    970                         if (fn(100*i / num, hal::app().res_wstr(HAL_NEWT_HASHING_PIECES))) 
    971                         { 
    972                                 // User canceled torrent creation. 
    973  
    974                                 hal::event_log.post(shared_ptr<hal::EventDetail>( 
    975                                         new hal::EventMsg(hal::app().res_wstr(HAL_NEWT_CREATION_CANCELED), hal::event_logger::info))); 
    976  
    977                                 return true; 
    978                         } 
    979                 } 
    980  
    981                 t_info->set_creator(to_utf8(params.creator).c_str()); 
    982                 t_info->set_comment(to_utf8(params.comment).c_str()); 
    983                  
    984                 t_info->set_priv(params.private_torrent); 
    985  
    986                 // create the torrent and print it to out 
    987                 libt::entry e = t_info->create_torrent(); 
    988                 halencode(out_file, e); 
    989                 } 
    990                 catch(const std::exception& e) 
    991                 { 
    992                         event_log.post(shared_ptr<EventDetail>( 
    993                                 new EventStdException(event_logger::fatal, e, L"create_torrent"))); 
    994                 }        
    995 */ 
    996                 return false; 
    997         } 
     908        bool create_torrent(const create_torrent_params& params, fs::wpath out_file, progress_callback fn); 
    998909         
    999910        libt::session session_;  
     
    1025936        bool dht_on_; 
    1026937        libt::dht_settings dht_settings_; 
    1027         libt::entry dht_state_; 
    1028          
     938        libt::entry dht_state_;  
    1029939}; 
    1030940 
Note: See TracChangeset for help on using the changeset viewer.