Changeset 620


Ignore:
Timestamp:
11/04/08 18:46:26 (11 years ago)
Author:
Eoin
Message:

Naming scheme improvements

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/Halite.sln

    r617 r620  
    1616        ProjectSection(ProjectDependencies) = postProject 
    1717                {333ECB6F-575B-4B11-BDDA-3E7F7555BAD8} = {333ECB6F-575B-4B11-BDDA-3E7F7555BAD8} 
    18         EndProjectSection 
    19 EndProject 
    20 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{2DE93320-DEB5-4CB1-AB8C-17875DFF3184}" 
    21         ProjectSection(SolutionItems) = preProject 
    22                 Halite.vsmdi = Halite.vsmdi 
    23                 LocalTestRun.testrunconfig = LocalTestRun.testrunconfig 
    2418        EndProjectSection 
    2519EndProject 
  • trunk/src/HaliteWindow.cpp

    r616 r620  
    5252BOOL HaliteWindow::PreTranslateMessage(MSG* pMsg) 
    5353{ 
    54         if(CFrameWindowImpl<HaliteWindow>::PreTranslateMessage(pMsg)) 
     54        if(CFrameWindowImpl<thisClass>::PreTranslateMessage(pMsg)) 
    5555                return TRUE; 
    5656 
     
    149149        // Add ToolBar and register it along with StatusBar for UIUpdates 
    150150        UIAddToolBar(hWndToolBar); 
    151         UISetCheck(ID_VIEW_TOOLBAR, 1); 
    152         UISetCheck(ID_VIEW_STATUS_BAR, 1); 
    153         UISetCheck(HAL_TRAY_MENU, 1);    
     151        UISetCheck(ID_VIEW_TOOLBAR, true); 
     152        UISetCheck(ID_VIEW_STATUS_BAR, true); 
     153        UISetCheck(HAL_TRAY_MENU, true);         
    154154         
    155155//      TBBUTTONINFO tbinfo = { sizeof(TBBUTTONINFO) }; 
     
    181181        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    182182                new hal::EventMsg(L"Initial setup complete!"))); 
     183 
     184        UpdateLayout(); 
    183185        issueUiUpdate(); 
    184          
     186 
     187                 
    185188        } 
    186189        catch(const std::exception& e) 
     
    224227                m_Split.SetSplitterPanes(haliteList, *mp_advDlg); 
    225228        } 
    226         ui().update(); 
     229 
     230        issueUiUpdate(); 
    227231} 
    228232 
     
    270274                UISetText(1, hal::app().res_wstr(HAL_IPFILTER_OFF).c_str()); 
    271275        } 
     276 
     277        UpdateLayout(); 
    272278         
    273279        } HAL_GENERIC_FN_EXCEPTION_CATCH(L"HaliteWindow::updateWindow()") 
     
    359365                wpath(default_move_folder), use_move_to); 
    360366 
    361         ui().update(); 
     367        issueUiUpdate(); 
    362368 
    363369        } 
     
    464470        } 
    465471         
     472        UpdateLayout(); 
    466473        SetMsgHandled(false); 
    467474}        
     
    535542        hal::bittorrent().pauseAllTorrents(); 
    536543         
    537         ui().update(); 
     544        issueUiUpdate(); 
    538545        return 0; 
    539546} 
     
    543550        hal::bittorrent().unpauseAllTorrents(); 
    544551         
    545         ui().update(); 
     552        issueUiUpdate(); 
    546553        return 0; 
    547554} 
  • trunk/src/HaliteWindow.hpp

    r616 r620  
    4040 
    4141class HaliteWindow : 
    42 //      public WTL::CFrameWindowImpl<HaliteWindow>, 
    43         public WTL::CAeroFrameImpl<HaliteWindow>, 
     42        public WTL::CFrameWindowImpl<HaliteWindow>, 
     43//      public WTL::CAeroFrameImpl<HaliteWindow>, 
    4444        public WTL::CUpdateUI<HaliteWindow>, 
    4545        public CDropFileTarget<HaliteWindow>, 
     
    4949        private boost::noncopyable 
    5050{ 
     51        typedef HaliteWindow thisClass; 
     52        typedef WTL::CFrameWindowImpl<thisClass> frameClass; 
     53        typedef WTL::CUpdateUI<thisClass> updateUiClass; 
     54        typedef CDropFileTarget<thisClass> dropClass; 
     55 
    5156public: 
    5257        HaliteWindow(unsigned ARE_YOU_ME); 
     
    5560        DECLARE_FRAME_WND_CLASS(NULL, HAL_MAINFRAME); 
    5661 
    57         ui_signal& ui() { return ui_; } 
    58  
    59         BEGIN_MSG_MAP_EX(HaliteWindow) 
     62//      ui_signal& ui() { return ui_; } 
     63 
     64        BEGIN_MSG_MAP_EX(thisClass) 
    6065                MSG_WM_CREATE(OnCreate) 
    6166                MSG_WM_CLOSE(OnClose) 
     
    9297 
    9398                REFLECT_NOTIFICATIONS() 
    94                 CHAIN_MSG_MAP(CUpdateUI<HaliteWindow>) 
    95 //              CHAIN_MSG_MAP(CFrameWindowImpl<HaliteWindow>) 
    96                 CHAIN_MSG_MAP(WTL::CAeroFrameImpl<HaliteWindow>) 
    97                 CHAIN_MSG_MAP(CDropFileTarget<HaliteWindow>) 
     99                CHAIN_MSG_MAP(frameClass) 
     100                CHAIN_MSG_MAP(updateUiClass) 
     101                CHAIN_MSG_MAP(dropClass) 
    98102        END_MSG_MAP() 
    99103 
     
    104108                UPDATE_ELEMENT(ID_VIEW_STATUS_BAR, UPDUI_MENUPOPUP) 
    105109        UPDATE_ELEMENT(0, UPDUI_STATUSBAR) 
    106         UPDATE_ELEMENT(1, UPDUI_STATUSBAR) 
     110                UPDATE_ELEMENT(1, UPDUI_STATUSBAR) 
    107111        UPDATE_ELEMENT(2, UPDUI_STATUSBAR) 
    108112        UPDATE_ELEMENT(3, UPDUI_STATUSBAR) 
  • trunk/src/halSession.hpp

    r618 r620  
    859859                                        , end(m_info.end_files(true)); i != end; ++i) 
    860860                                { 
    861                                         std::string p = (hal::path_to_utf8(pIT->saveDirectory()) / i->path).string(); 
     861                                        std::string p = (hal::path_to_utf8(pIT->save_directory()) / i->path).string(); 
    862862                                        fs::path bp = i->path.parent_path(); 
    863863                                         
     
    867867                                        { 
    868868                                                std::pair<std::set<std::string>::iterator, bool> ret =  
    869                                                         directories.insert((hal::path_to_utf8(pIT->saveDirectory()) / bp).string()); 
     869                                                        directories.insert((hal::path_to_utf8(pIT->save_directory()) / bp).string()); 
    870870                                                bp = bp.parent_path(); 
    871871                                        } 
  • trunk/src/halTorrent.cpp

    r618 r620  
    394394        try { 
    395395         
    396         pimpl->the_torrents_.get(filename)->getPeerDetails(peerContainer); 
     396        pimpl->the_torrents_.get(filename)->get_peer_details(peerContainer); 
    397397         
    398398        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllPeerDetails") 
     
    408408        try { 
    409409         
    410         pimpl->the_torrents_.get(filename)->getFileDetails(fileDetails); 
     410        pimpl->the_torrents_.get(filename)->get_file_details(fileDetails); 
    411411         
    412412        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllFileDetails") 
     
    746746        try { 
    747747         
    748         ptr->setTrackers(trackers); 
     748        ptr->set_trackers(trackers); 
    749749         
    750750        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers") 
     
    755755        try { 
    756756         
    757         ptr->resetTrackers(); 
     757        ptr->reset_trackers(); 
    758758         
    759759        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers") 
     
    764764        try {  
    765765 
    766         ptr->setFilePriorities(p.first, p.second); 
     766        ptr->set_file_priorities(p.first, p.second); 
    767767         
    768768        } HAL_GENERIC_TORRENT_PROP_EXCEPTION_CATCH("torrent::set_trackers") 
  • trunk/src/halTorrent.hpp

    r618 r620  
    386386//      const std::wstring& filename() const { return filename_; } 
    387387        const std::wstring& name() const { return name_; } 
    388         const std::wstring& saveDirectory() const { return saveDir_; } 
     388        const std::wstring& save_directory() const { return saveDir_; } 
    389389        const std::wstring& state() const { return state_; } 
    390390        const std::wstring& currentTracker() const { return currentTracker_; } 
  • trunk/src/halTorrentInternal.hpp

    r616 r620  
    448448                 
    449449                uploaded_.update(statusMemory_.total_upload); 
    450                 payloadUploaded_.update(statusMemory_.total_payload_upload); 
     450                payload_uploaded_.update(statusMemory_.total_payload_upload); 
    451451                downloaded_.update(statusMemory_.total_download); 
    452                 payloadDownloaded_.update(statusMemory_.total_payload_download); 
     452                payload_downloaded_.update(statusMemory_.total_payload_download); 
    453453                 
    454454                if (is_active()) 
    455455                { 
    456                         activeDuration_.update(); 
     456                        active_duration_.update(); 
    457457                         
    458458                        if (libt::torrent_status::seeding == statusMemory_.state) 
    459                                 seedingDuration_.update(); 
     459                                seeding_duration_.update(); 
    460460                }        
    461461                 
    462                 boost::tuple<size_t, size_t, size_t, size_t> connections = updatePeers();        
     462                boost::tuple<size_t, size_t, size_t, size_t> connections = update_peers();       
    463463 
    464464                return torrent_details_ptr(new torrent_details( 
    465465                        name_, filename_,  
    466                         saveDirectory().string(),  
     466                        save_directory().string(),  
    467467                        state,  
    468468                        hal::from_utf8(statusMemory_.current_tracker),  
     
    474474                        statusMemory_.total_wanted_done,  
    475475                        statusMemory_.total_wanted,  
    476                         uploaded_, payloadUploaded_, 
    477                         downloaded_, payloadDownloaded_,  
     476                        uploaded_, payload_uploaded_, 
     477                        downloaded_, payload_downloaded_,  
    478478                        connections,  
    479479                        ratio_,  
    480480                        td,  
    481481                        statusMemory_.next_announce,  
    482                         activeDuration_, seedingDuration_,  
     482                        active_duration_, seeding_duration_,  
    483483                        startTime_, finishTime_,  
    484484                        queue_position_, 
     
    499499                return torrent_details_ptr(new torrent_details( 
    500500                        name_, filename_,  
    501                         saveDirectory().string(),  
     501                        save_directory().string(),  
    502502                        app().res_wstr(HAL_TORRENT_STOPPED),  
    503503                        app().res_wstr(HAL_NA))); 
     
    532532                transferLimit_ = std::make_pair(down, up); 
    533533                 
    534                 applyTransferSpeed(); 
     534                apply_transfer_speed(); 
    535535        } 
    536536 
     
    542542                uploads_ = maxUpload; 
    543543                 
    544                 applyConnectionLimit(); 
     544                apply_connection_limit(); 
    545545        } 
    546546 
     
    898898                trackerPassword_ = password; 
    899899                 
    900                 applyTrackerLogin(); 
     900                apply_tracker_login(); 
    901901        }        
    902902         
     
    912912        const libt::torrent_handle& handle() const { return handle_; } 
    913913 
    914         void resetTrackers() 
     914        void reset_trackers() 
    915915        { 
    916916                if (in_session()) 
     
    921921        } 
    922922         
    923         void setTrackers(const std::vector<tracker_detail>& tracker_details) 
     923        void set_trackers(const std::vector<tracker_detail>& tracker_details) 
    924924        { 
    925925                trackers_.clear(); 
    926926                trackers_.assign(tracker_details.begin(), tracker_details.end()); 
    927927                 
    928                 applyTrackers(); 
     928                apply_trackers(); 
    929929        } 
    930930         
     
    944944        } 
    945945         
    946         void setFilePriorities(std::vector<int> fileIndices, int priority) 
     946        void set_file_priorities(std::vector<int> fileIndices, int priority) 
    947947        { 
    948948                if (!filePriorities_.empty()) 
     
    951951                                filePriorities_[i] = priority; 
    952952                                 
    953                         applyFilePriorities(); 
    954                 } 
    955         } 
    956  
    957         const wpath& saveDirectory() { return save_directory_; } 
     953                        apply_file_priorities(); 
     954                } 
     955        } 
     956 
     957        const wpath& save_directory() { return save_directory_; } 
    958958         
    959959    friend class boost::serialization::access; 
     
    974974                        ar & make_nvp("progress", progress_); 
    975975                        ar & make_nvp("state", state_); 
    976 //                      ar & make_nvp("compact_storage", compactStorage_);       
     976//                      ar & make_nvp("compact_storage", compact_storage_);      
    977977                        ar & make_nvp("allocation_type", allocation_);   
    978978                        ar & make_nvp("resolve_countries", resolve_countries_);  
     
    985985                        ar & make_nvp("move_to_directory", move_to_directory_); 
    986986                         
    987                         ar & make_nvp("payload_uploaded", payloadUploaded_); 
    988                         ar & make_nvp("payload_downloaded", payloadDownloaded_); 
     987                        ar & make_nvp("payload_uploaded", payload_uploaded_); 
     988                        ar & make_nvp("payload_downloaded", payload_downloaded_); 
    989989                        ar & make_nvp("uploaded", uploaded_); 
    990990                        ar & make_nvp("downloaded", downloaded_);                        
     
    994994                        ar & make_nvp("start_time", startTime_); 
    995995                        ar & make_nvp("finish_time", finishTime_); 
    996                         ar & make_nvp("active_duration", activeDuration_); 
    997                         ar & make_nvp("seeding_duration", seedingDuration_); 
     996                        ar & make_nvp("active_duration", active_duration_); 
     997                        ar & make_nvp("seeding_duration", seeding_duration_); 
    998998                        ar & make_nvp("managed", managed_); 
    999999                                         
     
    10181018                        } 
    10191019                         
    1020                         ar & make_nvp("payloadUploaded_", payloadUploaded_); 
    1021                         ar & make_nvp("payloadDownloaded_", payloadDownloaded_); 
     1020                        ar & make_nvp("payload_uploaded_", payload_uploaded_); 
     1021                        ar & make_nvp("payload_downloaded_", payload_downloaded_); 
    10221022                        ar & make_nvp("uploaded_", uploaded_); 
    10231023                        ar & make_nvp("downloaded_", downloaded_);       
     
    10341034                         
    10351035                        ar & make_nvp("startTime", startTime_); 
    1036                         ar & make_nvp("activeDuration", activeDuration_); 
    1037                         ar & make_nvp("seedingDuration", seedingDuration_); 
     1036                        ar & make_nvp("activeDuration", active_duration_); 
     1037                        ar & make_nvp("seedingDuration", seeding_duration_); 
    10381038                         
    10391039                        ar & make_nvp("name", name_); 
    1040                         ar & make_nvp("compactStorage", compactStorage_); 
     1040                        ar & make_nvp("compactStorage", compact_storage_); 
    10411041                        ar & make_nvp("finishTime", finishTime_); 
    10421042                         
     
    10531053        std::vector<libt::peer_info>& peers() { return peers_; } 
    10541054         
    1055         boost::tuple<size_t, size_t, size_t, size_t> updatePeers() 
     1055        boost::tuple<size_t, size_t, size_t, size_t> update_peers() 
    10561056        { 
    10571057                if (in_session()) 
     
    10861086        } 
    10871087         
    1088         void getPeerDetails(PeerDetails& peerDetails) const 
     1088        void get_peer_details(PeerDetails& peerDetails) const 
    10891089        { 
    10901090                if (in_session()) 
     
    10971097        } 
    10981098 
    1099         void getFileDetails(FileDetails& fileDetails) 
     1099        void get_file_details(FileDetails& fileDetails) 
    11001100        { 
    11011101                if (fileDetailsMemory_.empty()) 
     
    12021202        signalers signals_; 
    12031203 
    1204         void applySettings() 
     1204        void apply_settings() 
    12051205        {                
    1206                 applyTransferSpeed(); 
    1207                 applyConnectionLimit(); 
     1206                apply_transfer_speed(); 
     1207                apply_connection_limit(); 
    12081208                apply_ratio(); 
    1209                 applyTrackers(); 
    1210                 applyTrackerLogin(); 
    1211                 applyFilePriorities(); 
    1212                 applyResolveCountries(); 
    1213         } 
    1214          
    1215         void applyTransferSpeed() 
     1209                apply_trackers(); 
     1210                apply_tracker_login(); 
     1211                apply_file_priorities(); 
     1212                apply_resolve_countries(); 
     1213        } 
     1214         
     1215        void apply_transfer_speed() 
    12161216        { 
    12171217                mutex_t::scoped_lock l(mutex_); 
     
    12281228        } 
    12291229 
    1230         void applyConnectionLimit() 
     1230        void apply_connection_limit() 
    12311231        { 
    12321232                mutex_t::scoped_lock l(mutex_); 
     
    12511251        } 
    12521252         
    1253         void applyTrackers() 
     1253        void apply_trackers() 
    12541254        { 
    12551255                mutex_t::scoped_lock l(mutex_); 
     
    12761276        } 
    12771277         
    1278         void applyTrackerLogin() 
     1278        void apply_tracker_login() 
    12791279        { 
    12801280                mutex_t::scoped_lock l(mutex_); 
     
    12911291        } 
    12921292         
    1293         void applyFilePriorities() 
     1293        void apply_file_priorities() 
    12941294        {                
    12951295                mutex_t::scoped_lock l(mutex_); 
     
    13031303        }        
    13041304         
    1305         void applyResolveCountries() 
     1305        void apply_resolve_countries() 
    13061306        { 
    13071307                mutex_t::scoped_lock l(mutex_); 
     
    13911391        boost::int64_t totalBase_; 
    13921392         
    1393         transfer_tracker<boost::int64_t> payloadUploaded_; 
    1394         transfer_tracker<boost::int64_t> payloadDownloaded_; 
     1393        transfer_tracker<boost::int64_t> payload_uploaded_; 
     1394        transfer_tracker<boost::int64_t> payload_downloaded_; 
    13951395        transfer_tracker<boost::int64_t> uploaded_; 
    13961396        transfer_tracker<boost::int64_t> downloaded_; 
     
    13981398        pt::ptime startTime_; 
    13991399        pt::ptime finishTime_; 
    1400         duration_tracker activeDuration_; 
    1401         duration_tracker seedingDuration_; 
     1400        duration_tracker active_duration_; 
     1401        duration_tracker seeding_duration_; 
    14021402         
    14031403        std::vector<tracker_detail> trackers_; 
     
    14131413         
    14141414        int queue_position_; 
    1415         bool compactStorage_; 
     1415        bool compact_storage_; 
    14161416        bool managed_; 
    14171417        bit::allocations allocation_; 
Note: See TracChangeset for help on using the changeset viewer.