Changeset 478


Ignore:
Timestamp:
06/04/08 18:24:46 (12 years ago)
Author:
Eoin
Message:

Merged 0.3.1 changes into trunk.

Location:
trunk/src
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/AdvHaliteDialog.cpp

    r387 r478  
    2727*/       
    2828 
    29         hal::event().post(shared_ptr<hal::EventDetail>( 
     29        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    3030                new hal::EventMsg(L"Creating torrent tab...")));         
    3131        m_torrent.Create(tabCtrl_); 
    3232        tabCtrl_.AddPage(m_torrent, hal::app().res_wstr(HAL_TORRENT_TAB).c_str()); 
    3333         
    34         hal::event().post(shared_ptr<hal::EventDetail>( 
     34        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    3535                new hal::EventMsg(L"Creating peers tab...")));   
    3636        m_peers.Create(tabCtrl_); 
    3737        tabCtrl_.AddPage(m_peers, hal::app().res_wstr(HAL_PEERS_TAB).c_str()); 
    3838         
    39         hal::event().post(shared_ptr<hal::EventDetail>( 
     39        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    4040                new hal::EventMsg(L"Creating files tab...")));   
    4141        m_files.Create(tabCtrl_); 
    4242        tabCtrl_.AddPage(m_files, hal::app().res_wstr(HAL_FILES_TAB).c_str()); 
    4343         
    44         hal::event().post(shared_ptr<hal::EventDetail>( 
     44        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    4545                new hal::EventMsg(L"Creating tracker tab...")));         
    4646        m_tracker.Create(tabCtrl_); 
    4747        tabCtrl_.AddPage(m_tracker, hal::app().res_wstr(HAL_TRACKER_TAB).c_str()); 
    4848         
    49         hal::event().post(shared_ptr<hal::EventDetail>( 
     49        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    5050                new hal::EventMsg(L"Creating log tab...")));     
    5151        m_debug.Create(tabCtrl_); 
     
    5353         
    5454        tabCtrl_.SetCurrentPage(0); 
    55         hal::event().post(shared_ptr<hal::EventDetail>( 
     55        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    5656                new hal::EventMsg(L"All tabs complete!")));      
    5757         
     
    7272void AdvHaliteDialog::onClose() 
    7373{ 
    74         hal::event().post(shared_ptr<hal::EventDetail>( 
     74        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    7575                new hal::EventMsg(L"Closing Tabs!")));           
    7676 
  • trunk/src/ConfigOptions.hpp

    r403 r478  
    125125    int OnApply() 
    126126        {        
    127                 hal::event().post(shared_ptr<hal::EventDetail>( 
    128                         new hal::EventMsg(L"Applying general options.", hal::Event::info))); 
     127                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     128                        new hal::EventMsg(L"Applying general options.", hal::event_logger::info))); 
    129129 
    130130                size_t length = lang_list_.GetTextLen(lang_list_.GetCurSel()); 
     
    246246    int OnApply() 
    247247        { 
    248                 hal::event().post(shared_ptr<hal::EventDetail>( 
    249                         new hal::EventMsg(L"Applying bittorrent options.", hal::Event::info))); 
     248                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     249                        new hal::EventMsg(L"Applying bittorrent options.", hal::event_logger::info))); 
    250250 
    251251                onPortCheck(0, 0, GetDlgItem(IDC_BC_PORTCHECK)); 
     
    341341    int OnApply() 
    342342        { 
    343                 hal::event().post(shared_ptr<hal::EventDetail>( 
    344                         new hal::EventMsg(L"Applying proxy options.", hal::Event::info))); 
     343                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     344                        new hal::EventMsg(L"Applying proxy options.", hal::event_logger::info))); 
    345345 
    346346                return DoDataExchange(true); 
     
    490490    int OnApply() 
    491491        { 
    492                 hal::event().post(shared_ptr<hal::EventDetail>( 
    493                         new hal::EventMsg(L"Applying security options.", hal::Event::info))); 
     492                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     493                        new hal::EventMsg(L"Applying security options.", hal::event_logger::info))); 
    494494 
    495495                return DoDataExchange(true); 
     
    712712    int OnApply() 
    713713        { 
    714                 hal::event().post(shared_ptr<hal::EventDetail>( 
    715                         new hal::EventMsg(L"Applying torrent options.", hal::Event::info))); 
     714                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     715                        new hal::EventMsg(L"Applying torrent options.", hal::event_logger::info))); 
    716716 
    717717                hal::config().maxConnections = gTotalConnections_; 
     
    770770    int OnApply() 
    771771        { 
    772                 hal::event().post(shared_ptr<hal::EventDetail>( 
    773                         new hal::EventMsg(L"Applying remote options.", hal::Event::info))); 
     772                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     773                        new hal::EventMsg(L"Applying remote options.", hal::event_logger::info))); 
    774774 
    775775                return DoDataExchange(true); 
  • trunk/src/Halite.cpp

    r445 r478  
    4242                         
    4343                        wofs << (wformat(L"%1% %2%, %3%\r\n")  
    44                                 % event->timeStamp() % hal::Event::eventLevelToStr(event->level())  
     44                                % event->timeStamp() % hal::event_logger::eventLevelToStr(event->level())  
    4545                                % event->msg()).str(); 
    4646                         
     
    5151        void connect()  
    5252        {  
    53                 conn_ = hal::event().attach(bind(&halite_log_file::operator(), this, _1));  
     53                conn_ = hal::event_log.attach(bind(&halite_log_file::operator(), this, _1));  
    5454                assert(conn_.connected()); 
    5555        } 
     
    9090 
    9191//      HAL_DEV_MSG(L"Hello"); 
    92 //      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, L"Hello"))); 
     92//      hal::event_log.post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::event_logger::info, L"Hello"))); 
    9393 
    94         ::SetProcessAffinityMask(::GetCurrentProcess(), (DWORD_PTR)0x1); 
     94//      ::SetProcessAffinityMask(::GetCurrentProcess(), (DWORD_PTR)0x1); 
    9595         
    9696        try  
     
    141141        else 
    142142        { 
    143                 hal::event().post(shared_ptr<hal::EventDetail>( 
     143                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    144144                        new hal::EventMsg(wformat(L"Exe Path: %1%.") % hal::app().exe_path())));                 
    145145                 
    146                 hal::event().post(shared_ptr<hal::EventDetail>( 
     146                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    147147                        new hal::EventMsg(wformat(L"Initial Path: %1%.") % hal::app().initial_path())));                 
    148148                 
    149                 hal::event().post(shared_ptr<hal::EventDetail>( 
    150                         new hal::EventMsg((wformat(L"Working Directory: %1%.") % hal::app().working_directory()), hal::Event::info)));           
     149                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     150                        new hal::EventMsg((wformat(L"Working Directory: %1%.") % hal::app().working_directory()), hal::event_logger::info)));            
    151151                 
    152152                CMessageLoop theLoop; 
     
    170170                 
    171171                _Module.RemoveMessageLoop(); 
    172                  
     172 
     173                halite().save(); 
     174                hal::ini().save_data();          
    173175        } 
    174176        } 
  • trunk/src/Halite.hpp

    r459 r478  
    100100                load(); 
    101101        } 
    102  
    103         void saveIniData() 
    104         { 
    105                 save();          
    106                 hal::ini().save_data(); 
    107         } 
    108102         
    109103        friend class boost::serialization::access; 
  • trunk/src/HaliteDialogBase.hpp

    r370 r478  
    7575                        pT->focusChanged(focusedTorrent_ = focused); 
    7676                         
    77                         hal::event().post(shared_ptr<hal::EventDetail>( 
     77                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    7878                                new hal::EventMsg(L"Adv dialog focusChanged"))); 
    7979                } 
  • trunk/src/HaliteListViewCtrl.hpp

    r390 r478  
    3636                void sync_list(bool list_to_manager, bool signal_change=true) 
    3737                { 
    38 //                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"%1%, %2% %3%") % hal::from_utf8(selected_) % list_to_manager % signal_change).str().c_str()))); 
     38//                      hal::event_log.post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::event_logger::info, (wformat(L"%1%, %2% %3%") % hal::from_utf8(selected_) % list_to_manager % signal_change).str().c_str()))); 
    3939                        if (list_to_manager) 
    4040                        {        
     
    100100                        int itemPos = m_list_.FindItem(&findInfo, -1);   
    101101                         
    102 //                      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"%1%, %2%") % torrent_name % itemPos).str().c_str()))); 
     102//                      hal::event_log.post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::event_logger::info, (wformat(L"%1%, %2%") % torrent_name % itemPos).str().c_str()))); 
    103103                         
    104104                        if (itemPos == -1) 
  • trunk/src/HaliteWindow.cpp

    r474 r478  
    7171 
    7272 
    73         hal::event().post(shared_ptr<hal::EventDetail>( 
     73        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    7474                new hal::EventMsg(L"Loading Halite config..."))); 
    7575        hal::config().load(); 
    7676         
    77         hal::event().post(shared_ptr<hal::EventDetail>( 
     77        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    7878                new hal::EventMsg(L"Applying setting..."))); 
    7979        if (!hal::config().settingsChanged()) 
    8080        { 
    81                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    82                         new hal::EventDebug(hal::Event::critical, hal::app().res_wstr(HAL_WINDOW_SOCKETS_FAILED)))); 
     81                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     82                        new hal::EventDebug(hal::event_logger::critical, hal::app().res_wstr(HAL_WINDOW_SOCKETS_FAILED)))); 
    8383                         
    8484                MessageBox(hal::app().res_wstr(HAL_WINDOW_SOCKETS_FAILED).c_str(), 0, 0); 
     
    8888        } 
    8989         
    90         hal::event().post(shared_ptr<hal::EventDetail>( 
     90        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    9191                new hal::EventMsg(L"Starting GUI..."))); 
    9292         
     
    115115        m_hWndClient = m_Split.m_hWnd; 
    116116 
    117         hal::event().post(shared_ptr<hal::EventDetail>( 
     117        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    118118                new hal::EventMsg(L"Creating main listview...")));       
    119119        // Create ListView and Dialog 
     
    123123 
    124124 
    125         hal::event().post(shared_ptr<hal::EventDetail>( 
     125        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    126126                new hal::EventMsg(L"Creating classic dialog...")));              
    127127        mp_dlg.reset(new HaliteDialog(*this)), 
     
    130130         
    131131 
    132         hal::event().post(shared_ptr<hal::EventDetail>( 
     132        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    133133                new hal::EventMsg(L"Creating advanced dialog..."))); 
    134134        mp_advDlg.reset(new AdvHaliteDialog(*this)); 
     
    138138//      m_Split.SetSplitterPanes(*mp_list, *mp_dlg); 
    139139         
    140         hal::event().post(shared_ptr<hal::EventDetail>( 
     140        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    141141                new hal::EventMsg(L"Creating tray icon...")));   
    142142        // Create the tray icon. 
     
    161161        connectUiUpdate(bind(&HaliteWindow::updateWindow, this)); 
    162162         
    163         hal::event().post(shared_ptr<hal::EventDetail>( 
     163        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    164164                new hal::EventMsg(L"Registering drop target...")));      
    165165        RegisterDropTarget(); 
     
    174174        setCorrectDialog(); 
    175175         
    176         hal::event().post(shared_ptr<hal::EventDetail>( 
     176        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    177177                new hal::EventMsg(L"Starting event reciever..."))); 
    178178        hal::bittorrent().startEventReceiver(); 
    179         hal::event().post(shared_ptr<hal::EventDetail>( 
     179        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    180180                new hal::EventMsg(L"Initial setup complete!"))); 
    181181        issueUiUpdate(); 
     
    184184        catch(const std::exception& e) 
    185185        { 
    186                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    187                         new hal::EventStdException(hal::Event::critical, e, L"HaliteWindow::OnCreate")));  
     186                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     187                        new hal::EventStdException(hal::event_logger::critical, e, L"HaliteWindow::OnCreate")));  
    188188 
    189189                DestroyWindow(); 
     
    272272        catch (std::exception& e) 
    273273        { 
    274                 hal::event().post(shared_ptr<hal::EventDetail>(\ 
    275                         new hal::EventStdException(hal::Event::info, e, L"updateWindow"))); 
     274                hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
     275                        new hal::EventStdException(hal::event_logger::info, e, L"updateWindow"))); 
    276276        } 
    277277} 
     
    287287                try 
    288288                { 
    289                  
    290                 halite().saveIniData(); 
     289 
     290                hal::ini().save_data(); 
    291291                hal::bittorrent().saveTorrentData();     
    292292         
     
    294294                catch (std::exception& e) 
    295295                { 
    296                         hal::event().post(shared_ptr<hal::EventDetail>(\ 
    297                                 new hal::EventStdException(hal::Event::info, e, L"saveTimer"))); 
     296                        hal::event_log.post(shared_ptr<hal::EventDetail>(\ 
     297                                new hal::EventStdException(hal::event_logger::info, e, L"saveTimer"))); 
    298298                } 
    299299        } 
     
    317317        catch (std::exception& e) 
    318318        { 
    319                 hal::event().post(shared_ptr<hal::EventDetail>( 
    320                         new hal::EventStdException(hal::Event::info, e, L"updateTimer"))); 
     319                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     320                        new hal::EventStdException(hal::event_logger::info, e, L"updateTimer"))); 
    321321        } 
    322322} 
     
    324324LRESULT HaliteWindow::OnCopyData(HWND, PCOPYDATASTRUCT pCSD) 
    325325{ 
    326         hal::event().post(shared_ptr<hal::EventDetail>( 
     326        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    327327                new hal::EventMsg(L"I recieved data."))); 
    328328                 
     
    333333                        wstring filename(static_cast<wchar_t*>(pCSD->lpData), pCSD->cbData/sizeof(wchar_t)); 
    334334                         
    335                         hal::event().post(shared_ptr<hal::EventDetail>( 
    336                                 new hal::EventMsg((wformat(L"Recieved data: %1%.") % filename), hal::Event::info))); 
     335                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     336                                new hal::EventMsg((wformat(L"Recieved data: %1%.") % filename), hal::event_logger::info))); 
    337337                 
    338338                        ProcessFile(filename.c_str()); 
     
    376376        catch(const boost::filesystem::filesystem_error&) 
    377377        { 
    378                 hal::event().post(shared_ptr<hal::EventDetail>( 
    379                         new hal::EventDebug(hal::Event::warning, L"filesystem error"))); 
     378                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     379                        new hal::EventDebug(hal::event_logger::warning, L"filesystem error"))); 
    380380        } 
    381381} 
     
    404404 
    405405        hal::bittorrent().stopEventReceiver(); 
    406         Sleep(200); 
     406        Sleep(3000); 
    407407 
    408408        hal::bittorrent().shutDownSession(); 
     
    418418        splitterPos = m_Split.GetSplitterPos(); 
    419419 
    420         hal::config().save(); 
    421420        save(); 
    422         halite().save(); 
    423421        hal::ini().save_data(); 
    424422         
     
    438436        } 
    439437 
    440         hal::config().save(); 
     438        // Resave for sake of your health. 
    441439        save(); 
    442440        halite().save(); 
     
    581579LRESULT HaliteWindow::OnAreYouMe(UINT, WPARAM, LPARAM, BOOL&)  
    582580{ 
    583         hal::event().post(shared_ptr<hal::EventDetail>( 
     581        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    584582                new hal::EventMsg(L"I tried to contact me.")));          
    585583 
  • trunk/src/NewTorrentDialog.cpp

    r472 r478  
    142142        catch(const std::exception& e) 
    143143        { 
    144                 hal::event().post(shared_ptr<hal::EventDetail>( 
    145                         new hal::EventStdException(hal::Event::fatal, e, L"DetailsSheet::OnDirBrowse"))); 
     144                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     145                        new hal::EventStdException(hal::event_logger::fatal, e, L"DetailsSheet::OnDirBrowse"))); 
    146146        } 
    147147} 
     
    189189        catch(const std::exception& e) 
    190190        { 
    191                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    192                         new hal::EventStdException(hal::Event::critical, e,  
     191                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     192                        new hal::EventStdException(hal::event_logger::critical, e,  
    193193                                L"DetailsSheet::FileSizePairs"))); 
    194194        } 
     
    360360    resizeClass::DlgResize_Init(false, true, WS_CLIPCHILDREN); 
    361361 
    362         hal::event().post(shared_ptr<hal::EventDetail>( 
     362        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    363363                new hal::EventMsg(L"NewTorrentDialog::OnShowWindow()"))); 
    364364 
     
    399399        { 
    400400 
    401         hal::event().post(shared_ptr<hal::EventDetail>( 
     401        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    402402                new hal::EventMsg(L"NewTorrentDialog::OnSave()"))); 
    403403 
     
    429429        catch(const std::exception& e) 
    430430        { 
    431                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    432                         new hal::EventStdException(hal::Event::critical, e,  
     431                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     432                        new hal::EventStdException(hal::event_logger::critical, e,  
    433433                                L"NewTorrentDialog::OnSave"))); 
    434434        } 
  • trunk/src/NewTorrentPeersLV.cpp

    r432 r478  
    9292        catch(const std::exception& e) 
    9393        { 
    94                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    95                         new hal::EventStdException(hal::Event::critical, e,  
     94                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     95                        new hal::EventStdException(hal::event_logger::critical, e,  
    9696                                L"NewTorrent_PeersListViewCtrl::editItem"))); 
    9797        } 
  • trunk/src/SplashDialog.hpp

    r474 r478  
    112112                SetDlgItemText(HAL_CSPLASH_NUM_ACT, hal::app().res_wstr(HAL_CSPLASH_SHUTDOWN_MSG).c_str()); 
    113113 
     114                hal::bittorrent().stopEventReceiver(); 
     115                Sleep(3000); 
     116 
    114117                hal::bittorrent().shutDownSession(); 
    115118                 
  • trunk/src/WTLx/DdxEx.hpp

    r395 r478  
    115115                        catch(boost::bad_lexical_cast &) 
    116116                        { 
    117                                 hal::event().post(shared_ptr<hal::EventDetail>( 
     117                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    118118                                        new hal::EventMsg(L"Save bad_lexical_cast"))); 
    119119                                         
     
    145145                        catch(boost::bad_lexical_cast &) 
    146146                        { 
    147                                 hal::event().post(shared_ptr<hal::EventDetail>( 
     147                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
    148148                                        new hal::EventMsg(L"Load bad_lexical_cast"))); 
    149149                                         
  • trunk/src/WTLx/SelectionManager.hpp

    r423 r478  
    156156        void setSelected(int itemPos) 
    157157        {                
    158                 hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"Set Selected %1%") % itemPos).str().c_str()))); 
     158                hal::event_log.post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::event_logger::info, (wformat(L"Set Selected %1%") % itemPos).str().c_str()))); 
    159159 
    160160                LVITEM lvi = { LVIF_STATE }; 
  • trunk/src/advtabs/Debug.hpp

    r447 r478  
    158158 
    159159                SetItemText(itemPos, 2, 
    160                         hal::Event::eventLevelToStr(event->level()).c_str()); 
     160                        hal::event_logger::eventLevelToStr(event->level()).c_str()); 
    161161                         
    162162                if (halite().logListLen() <= GetItemCount()) 
     
    185185                ApplyDetails(); 
    186186                 
    187                 conn_ = hal::event().attach(bind(&LogListViewCtrl::operator(), this, _1)); 
     187                conn_ = hal::event_log.attach(bind(&LogListViewCtrl::operator(), this, _1)); 
    188188        } 
    189189 
  • trunk/src/advtabs/Files.cpp

    r456 r478  
    224224void AdvFilesDialog::doUiUpdate() 
    225225{ 
    226 //      hal::event().post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::Event::info, (wformat(L"doUiUpdate %1%") % current_torrent_name_).str().c_str()))); 
     226//      hal::event_log.post(shared_ptr<hal::EventDetail>(new hal::EventDebug(hal::event_logger::info, (wformat(L"doUiUpdate %1%") % current_torrent_name_).str().c_str()))); 
    227227 
    228228        tree_.determineFocused(); 
  • trunk/src/advtabs/Files.hpp

    r423 r478  
    4040                order_(f.order()) 
    4141        { 
    42 //              hal::event().post(shared_ptr<hal::EventDetail>( 
     42//              hal::event_log.post(shared_ptr<hal::EventDetail>( 
    4343//                      new hal::EventMsg(wformat(L"Con -> %1% - %2%.") % filename % order())));         
    4444        } 
  • trunk/src/halConfig.cpp

    r438 r478  
    2424bool Config::settingsThread() 
    2525{        
    26         event().post(shared_ptr<EventDetail>(new EventMsg(L"Applying BitTorrent session settings.")));   
     26        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Applying BitTorrent session settings.")));         
    2727 
    2828        bittorrent().setMapping(mappingType);    
    2929 
    30         event().post(shared_ptr<EventDetail>(new EventMsg( 
     30        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    3131                        wformat(L"Trying port in range %1% - %2%.") % portFrom % portTo))); 
    3232        try 
     
    3636        if (!success) 
    3737        { 
    38                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    39                         new hal::EventDebug(Event::critical, L"settingsThread, Init"))); 
     38                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     39                        new hal::EventDebug(event_logger::critical, L"settingsThread, Init"))); 
    4040                 
    4141                return false; 
     
    4444        catch(const std::exception& e) 
    4545        { 
    46                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    47                         new hal::EventStdException(Event::critical, e, L"settingsThread, Init")));  
     46                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     47                        new hal::EventStdException(event_logger::critical, e, L"settingsThread, Init")));  
    4848                 
    4949                return false; 
    5050        } 
    5151 
    52         event().post(shared_ptr<EventDetail>(new EventMsg(wformat(L"Opened listen port; %1%.") % bittorrent().isListeningOn()))); 
     52        event_log.post(shared_ptr<EventDetail>(new EventMsg(wformat(L"Opened listen port; %1%.") % bittorrent().isListeningOn()))); 
    5353         
    5454        try 
     
    6565        catch(const std::exception& e) 
    6666        { 
    67                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    68                         new hal::EventStdException(Event::critical, e, L"settingsThread, Load IP Filter")));  
     67                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     68                        new hal::EventStdException(event_logger::critical, e, L"settingsThread, Load IP Filter")));  
    6969        }        
    7070 
     
    8080        catch(const std::exception& e) 
    8181        { 
    82                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    83                                 new hal::EventStdException(Event::critical, e, L"settingsThread, Protocol Encryption")));  
     82                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     83                                new hal::EventStdException(event_logger::critical, e, L"settingsThread, Protocol Encryption")));  
    8484        } 
    8585         
     
    109109                        bittorrent().ensureDhtOff(); 
    110110                         
    111                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    112                                 new hal::EventDebug(Event::critical, L"settingsThread, DHT Error")));  
     111                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     112                                new hal::EventDebug(event_logger::critical, L"settingsThread, DHT Error")));  
    113113                } 
    114114        } 
     
    116116                bittorrent().ensureDhtOff(); 
    117117                 
     118        // Settings seem to have applied ok! 
     119        save();  
    118120        return true; 
    119121} 
  • trunk/src/halEvent.cpp

    r404 r478  
    2626#include <libtorrent/peer_connection.hpp> 
    2727 
     28#define HAL_EVENT_IMPL_UNIT 
    2829#include "halEvent.hpp" 
    2930 
     
    3132{ 
    3233 
    33 void Event::post(boost::shared_ptr<EventDetail> event) 
     34static boost::shared_ptr<event_impl> s_event_impl; 
     35 
     36struct event_impl 
    3437{ 
    35         if (event->level() != hal::Event::debug || halite().logDebug()) 
    36                 signal(event); 
     38        mutable mutex_t mutex_; 
     39        boost::signal<void (boost::shared_ptr<EventDetail>)> event_signal_; 
     40}; 
     41 
     42event_logger::event_logger() 
     43{ 
     44        if (!s_event_impl) 
     45                s_event_impl.reset(new event_impl()); 
     46 
     47        pimpl_ = s_event_impl; 
     48} 
     49 
     50event_logger::~event_logger() 
     51{} 
     52 
     53boost::signals::connection event_logger::attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn) 
     54{ 
     55        mutex_t::scoped_lock l(pimpl_->mutex_); 
     56        return pimpl_->event_signal_.connect(fn); 
     57} 
     58 
     59void event_logger::dettach(const boost::signals::connection& c) 
     60{ 
     61        mutex_t::scoped_lock l(pimpl_->mutex_); 
     62        pimpl_->event_signal_.disconnect(c); 
     63} 
     64 
     65void event_logger::post(boost::shared_ptr<EventDetail> e) 
     66{ 
     67        mutex_t::scoped_lock l(pimpl_->mutex_); 
     68        if (e->level() != hal::event_logger::debug || halite().logDebug()) 
     69                pimpl_->event_signal_(e); 
    3770} 
    3871         
    39 std::wstring Event::eventLevelToStr(eventLevel event) 
     72std::wstring event_logger::eventLevelToStr(eventLevel event) 
    4073{ 
    4174        switch (event) 
     
    5689} 
    5790 
    58 Event& event() 
    59 { 
    60         static Event e; 
    61         return e; 
    62 } 
    63  
    6491} // namespace hal 
  • trunk/src/halEvent.hpp

    r459 r478  
    3434#ifdef TORRENT_LOGGING 
    3535#       define HAL_DEV_MSG(msg) \ 
    36         hal::event().post(boost::shared_ptr<hal::EventDetail>( \ 
    37                         new hal::EventMsg(msg, hal::Event::dev)))  
     36        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( \ 
     37                        new hal::EventMsg(msg, hal::event_logger::dev)))  
    3838#else 
    3939#       define HAL_DEV_MSG(msg) 
     
    4343{ 
    4444 
    45 class Event 
    46 { 
    47 public: 
     45struct event_impl; 
     46 
     47class event_logger : private boost::noncopyable 
     48{        
     49public:  
    4850        enum eventLevel { dev, debug, info, warning, critical, fatal, none }; 
    4951         
     
    6365        }; 
    6466         
    65         static std::wstring eventLevelToStr(eventLevel);         
    66         void post(boost::shared_ptr<EventDetail> event); 
    67          
    68         boost::signals::connection attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn) 
    69         { 
    70                 return event_signal_.connect(fn); 
    71         } 
    72  
    73         void signal(boost::shared_ptr<EventDetail> e) 
    74         { 
    75                 mutex_t::scoped_lock l(mutex_); 
    76  
    77                 event_signal_(e); 
    78         } 
    79          
    80 private: 
    81         mutable mutex_t mutex_; 
    82  
    83         boost::signal<void (boost::shared_ptr<EventDetail>)> event_signal_; 
    84 }; 
    85  
    86 Event& event(); 
     67        event_logger(); 
     68        ~event_logger(); 
     69 
     70        bool is_active() { return pimpl_; } 
     71 
     72        boost::signals::connection attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn); 
     73        void dettach(const boost::signals::connection& c); 
     74 
     75        void post(boost::shared_ptr<EventDetail> e); 
     76         
     77        static std::wstring eventLevelToStr(eventLevel); 
     78 
     79private: 
     80        std::vector<boost::signals::scoped_connection> connections_; 
     81        boost::shared_ptr<event_impl> pimpl_; 
     82}; 
     83 
     84#ifndef HAL_EVENT_IMPL_UNIT 
     85static event_logger event_log; 
     86#endif 
    8787 
    8888class EventDetail 
    8989{ 
    9090public: 
    91         EventDetail(Event::eventLevel l, boost::posix_time::ptime t, Event::codes c) : 
     91        EventDetail(event_logger::eventLevel l, boost::posix_time::ptime t, event_logger::codes c) : 
    9292                level_(l), 
    9393                timeStamp_(t), 
     
    102102        } 
    103103 
    104         Event::eventLevel level() { return level_; } 
     104        event_logger::eventLevel level() { return level_; } 
    105105        boost::posix_time::ptime timeStamp() { return timeStamp_; } 
    106         Event::codes code() { return code_; } 
     106        event_logger::codes code() { return code_; } 
    107107         
    108108private:         
    109         Event::eventLevel level_; 
     109        event_logger::eventLevel level_; 
    110110        boost::posix_time::ptime timeStamp_; 
    111         Event::codes code_; 
     111        event_logger::codes code_; 
    112112}; 
    113113 
     
    115115{ 
    116116public: 
    117         EventLibtorrent(Event::eventLevel l, boost::posix_time::ptime t, Event::codes c, std::wstring m) : 
     117        EventLibtorrent(event_logger::eventLevel l, boost::posix_time::ptime t, event_logger::codes c, std::wstring m) : 
    118118                EventDetail(l, t, c), 
    119119                msg_(m) 
     
    132132{ 
    133133public: 
    134         EventGeneral(Event::eventLevel l, Event::codes c, std::wstring m) : 
     134        EventGeneral(event_logger::eventLevel l, event_logger::codes c, std::wstring m) : 
    135135                EventDetail(l, boost::posix_time::second_clock::universal_time(), c), 
    136136                msg_(m) 
    137137        {} 
    138138         
    139         EventGeneral(Event::eventLevel l, boost::posix_time::ptime t, std::wstring m) : 
    140                 EventDetail(l, t, Event::noEvent), 
     139        EventGeneral(event_logger::eventLevel l, boost::posix_time::ptime t, std::wstring m) : 
     140                EventDetail(l, t, event_logger::noEvent), 
    141141                msg_(m) 
    142142        {} 
    143143         
    144144        template<typename str_t> 
    145         EventGeneral(Event::eventLevel l, str_t m) : 
    146                 EventDetail(l, boost::posix_time::second_clock::universal_time(), Event::noEvent), 
     145        EventGeneral(event_logger::eventLevel l, str_t m) : 
     146                EventDetail(l, boost::posix_time::second_clock::universal_time(), event_logger::noEvent), 
    147147                msg_(hal::to_wstr_shim(m)) 
    148148        {} 
    149149         
    150150        template<typename str_t>         
    151         EventGeneral(Event::eventLevel l, boost::posix_time::ptime t, str_t m) : 
    152                 EventDetail(l, t, Event::noEvent), 
     151        EventGeneral(event_logger::eventLevel l, boost::posix_time::ptime t, str_t m) : 
     152                EventDetail(l, t, event_logger::noEvent), 
    153153                msg_(hal::to_wstr_shim(m)) 
    154154        {} 
     
    156156        virtual std::wstring msg() 
    157157        { 
    158                 if (Event::noEvent != code()) 
     158                if (event_logger::noEvent != code()) 
    159159                        return (boost::wformat(hal::app().res_wstr(code())) % msg_).str(); 
    160160                else 
     
    170170public: 
    171171        template<typename str_t> 
    172         EventMsg(str_t m, Event::eventLevel l=Event::debug,  
    173                 boost::posix_time::ptime t=boost::posix_time::second_clock::universal_time(), Event::codes c=Event::noEvent) : 
     172        EventMsg(str_t m, event_logger::eventLevel l=event_logger::debug,  
     173                boost::posix_time::ptime t=boost::posix_time::second_clock::universal_time(), event_logger::codes c=event_logger::noEvent) : 
    174174                EventDetail(l, t, c), 
    175175                msg_(hal::to_wstr_shim(m)) 
     
    178178        virtual std::wstring msg() 
    179179        { 
    180                 if (Event::noEvent != code()) 
     180                if (event_logger::noEvent != code()) 
    181181                        return (boost::wformat(hal::app().res_wstr(code())) % msg_).str(); 
    182182                else 
     
    191191{ 
    192192public: 
    193         EventPeerAlert(Event::eventLevel l, boost::posix_time::ptime t, std::wstring m) : 
    194                 EventDetail(l, t, Event::peer), 
     193        EventPeerAlert(event_logger::eventLevel l, boost::posix_time::ptime t, std::wstring m) : 
     194                EventDetail(l, t, event_logger::peer), 
    195195                msg_(m) 
    196196        {} 
     
    209209public: 
    210210        EventXmlException(std::wstring e, std::wstring m) : 
    211                 EventDetail(Event::warning, boost::posix_time::second_clock::universal_time(), Event::xmlException), 
     211                EventDetail(event_logger::warning, boost::posix_time::second_clock::universal_time(), event_logger::xmlException), 
    212212                exp_(e), 
    213213                msg_(m) 
     
    228228public: 
    229229        template<typename t_str, typename f_str> 
    230         EventInvalidTorrent(Event::eventLevel l, Event::codes code, t_str t, f_str f) : 
     230        EventInvalidTorrent(event_logger::eventLevel l, event_logger::codes code, t_str t, f_str f) : 
    231231                EventDetail(l, boost::posix_time::second_clock::universal_time(), code), 
    232232                torrent_(hal::to_wstr_shim(t)), 
     
    249249public: 
    250250        template<typename e_str, typename t_str, typename f_str> 
    251         EventTorrentException(Event::eventLevel l, Event::codes code, e_str e, t_str t, f_str f) : 
     251        EventTorrentException(event_logger::eventLevel l, event_logger::codes code, e_str e, t_str t, f_str f) : 
    252252                EventDetail(l, boost::posix_time::second_clock::universal_time(), code), 
    253253                torrent_(hal::to_wstr_shim(t)), 
     
    270270{ 
    271271public: 
    272         EventStdException(Event::eventLevel l, const std::exception& e, std::wstring from) : 
    273                 EventDetail(l, boost::posix_time::second_clock::universal_time(), Event::generalException), 
     272        EventStdException(event_logger::eventLevel l, const std::exception& e, std::wstring from) : 
     273                EventDetail(l, boost::posix_time::second_clock::universal_time(), event_logger::generalException), 
    274274                exception_(hal::from_utf8(e.what())), 
    275275                from_(from) 
     
    289289{ 
    290290public: 
    291         EventDebug(Event::eventLevel l, std::wstring msg) : 
    292                 EventDetail(l, boost::posix_time::second_clock::universal_time(), Event::debugEvent), 
     291        EventDebug(event_logger::eventLevel l, std::wstring msg) : 
     292                EventDetail(l, boost::posix_time::second_clock::universal_time(), event_logger::debugEvent), 
    293293                msg_(msg) 
    294294        {} 
     
    308308        template<typename T> 
    309309        EventInfo(T msg) : 
    310                 EventDetail(Event::info, boost::posix_time::second_clock::universal_time(), Event::infoCode), 
     310                EventDetail(event_logger::info, boost::posix_time::second_clock::universal_time(), event_logger::infoCode), 
    311311                msg_(to_wstr_shim(msg)) 
    312312        {} 
  • trunk/src/halIni.hpp

    r441 r478  
    7070                catch (const std::exception& e) 
    7171                {                        
    72                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     72                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    7373                                new hal::EventXmlException(hal::from_utf8(e.what()), L"load_standalone")));  
    7474 
     
    9393                catch (const std::exception& e) 
    9494                {                        
    95                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     95                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    9696                                new hal::EventXmlException(hal::from_utf8(e.what()), hal::from_utf8(name_))));  
    9797                } 
  • trunk/src/halTorrent.cpp

    r474 r478  
    196196} 
    197197 
    198 static Event::eventLevel lbtAlertToHalEvent(libt::alert::severity_t severity) 
     198static event_logger::eventLevel lbtAlertToHalEvent(libt::alert::severity_t severity) 
    199199{ 
    200200        switch (severity) 
    201201        { 
    202202        case libt::alert::debug: 
    203                 return Event::debug; 
     203                return event_logger::debug; 
    204204         
    205205        case libt::alert::info: 
    206                 return Event::info; 
     206                return event_logger::info; 
    207207         
    208208        case libt::alert::warning: 
    209                 return Event::warning; 
     209                return event_logger::warning; 
    210210         
    211211        case libt::alert::critical: 
    212212        case libt::alert::fatal: 
    213                 return Event::critical; 
     213                return event_logger::critical; 
    214214         
    215215        default: 
    216                 return Event::none; 
     216                return event_logger::none; 
    217217        } 
    218218} 
     
    250250        std::stable_sort(torrents_.begin(), torrents_.end(), fn); 
    251251} 
    252  
    253252 
    254253web_seed_or_dht_node_detail::web_seed_or_dht_node_detail() :  
     
    304303                catch(std::exception& e) 
    305304                { 
    306                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    307                                 new hal::EventStdException(Event::critical, e, L"~BitTorrent_impl")));  
     305                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     306                                new hal::EventStdException(event_logger::critical, e, L"~BitTorrent_impl")));  
    308307                } 
    309308        } 
     
    341340                void operator()(libt::torrent_finished_alert const& a) const 
    342341                { 
    343                         event().post(shared_ptr<EventDetail>( 
     342                        event_log.post(shared_ptr<EventDetail>( 
    344343                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
    345344                                                % get(a.handle)->name()),  
    346                                         Event::info, a.timestamp()))); 
     345                                        event_logger::info, a.timestamp()))); 
    347346                         
    348347                        get(a.handle)->finished();       
     
    351350                void operator()(libt::torrent_paused_alert const& a) const 
    352351                { 
    353                         event().post(shared_ptr<EventDetail>( 
     352                        event_log.post(shared_ptr<EventDetail>( 
    354353                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
    355354                                                % get(a.handle)->name()),  
    356                                         Event::info, a.timestamp()))); 
     355                                        event_logger::info, a.timestamp()))); 
    357356 
    358357                        get(a.handle)->signals().torrent_paused(); 
     
    361360                void operator()(libt::peer_error_alert const& a) const 
    362361                { 
    363                         event().post(shared_ptr<EventDetail>( 
     362                        event_log.post(shared_ptr<EventDetail>( 
    364363                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    365364                                        wformat(hal::app().res_wstr(HAL_PEER_ALERT)) 
     
    371370                void operator()(libt::peer_ban_alert const& a) const 
    372371                { 
    373                         event().post(shared_ptr<EventDetail>( 
     372                        event_log.post(shared_ptr<EventDetail>( 
    374373                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    375374                                        wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
     
    381380                void operator()(libt::hash_failed_alert const& a) const 
    382381                { 
    383                         event().post(shared_ptr<EventDetail>( 
     382                        event_log.post(shared_ptr<EventDetail>( 
    384383                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    385384                                        wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
     
    391390                void operator()(libt::url_seed_alert const& a) const 
    392391                { 
    393                         event().post(shared_ptr<EventDetail>( 
     392                        event_log.post(shared_ptr<EventDetail>( 
    394393                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    395394                                        wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
     
    402401                void operator()(libt::tracker_warning_alert const& a) const 
    403402                { 
    404                         event().post(shared_ptr<EventDetail>( 
     403                        event_log.post(shared_ptr<EventDetail>( 
    405404                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    406405                                        wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
     
    412411                void operator()(libt::tracker_announce_alert const& a) const 
    413412                { 
    414                         event().post(shared_ptr<EventDetail>( 
     413                        event_log.post(shared_ptr<EventDetail>( 
    415414                                new EventMsg((wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
    416415                                                % get(a.handle)->name()),  
    417                                         Event::info, a.timestamp()))); 
     416                                        event_logger::info, a.timestamp()))); 
    418417                } 
    419418                 
    420419                void operator()(libt::tracker_alert const& a) const 
    421420                { 
    422                         event().post(shared_ptr<EventDetail>( 
     421                        event_log.post(shared_ptr<EventDetail>( 
    423422                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    424423                                        wformat(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
     
    432431                void operator()(libt::tracker_reply_alert const& a) const 
    433432                { 
    434                         event().post(shared_ptr<EventDetail>( 
     433                        event_log.post(shared_ptr<EventDetail>( 
    435434                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    436435                                        wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
     
    443442                void operator()(libt::fastresume_rejected_alert const& a) const 
    444443                { 
    445                         event().post(shared_ptr<EventDetail>( 
     444                        event_log.post(shared_ptr<EventDetail>( 
    446445                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    447446                                        wformat(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
     
    453452                void operator()(libt::piece_finished_alert const& a) const 
    454453                { 
    455                         event().post(shared_ptr<EventDetail>( 
    456                                 new EventGeneral(Event::debug, a.timestamp(), 
     454                        event_log.post(shared_ptr<EventDetail>( 
     455                                new EventGeneral(event_logger::debug, a.timestamp(), 
    457456                                        wformat(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT)) 
    458457                                                % get(a.handle)->name() 
     
    463462                void operator()(libt::block_finished_alert const& a) const 
    464463                { 
    465                         event().post(shared_ptr<EventDetail>( 
    466                                 new EventGeneral(Event::debug, a.timestamp(), 
     464                        event_log.post(shared_ptr<EventDetail>( 
     465                                new EventGeneral(event_logger::debug, a.timestamp(), 
    467466                                        wformat(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT)) 
    468467                                                % get(a.handle)->name() 
     
    474473                void operator()(libt::block_downloading_alert const& a) const 
    475474                { 
    476                         event().post(shared_ptr<EventDetail>( 
    477                                 new EventGeneral(Event::debug, a.timestamp(), 
     475                        event_log.post(shared_ptr<EventDetail>( 
     476                                new EventGeneral(event_logger::debug, a.timestamp(), 
    478477                                        wformat(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT)) 
    479478                                                % get(a.handle)->name() 
     
    487486                        if (a.endpoint.address().is_v6()) 
    488487                        {        
    489                                 event().post(shared_ptr<EventDetail>( 
    490                                         new EventGeneral(Event::info, a.timestamp(), 
     488                                event_log.post(shared_ptr<EventDetail>( 
     489                                        new EventGeneral(event_logger::info, a.timestamp(), 
    491490                                                hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT)) 
    492491                                )       );               
     
    494493                        else 
    495494                        { 
    496                                 event().post(shared_ptr<EventDetail>( 
    497                                         new EventGeneral(Event::info, a.timestamp(), 
     495                                event_log.post(shared_ptr<EventDetail>( 
     496                                        new EventGeneral(event_logger::info, a.timestamp(), 
    498497                                                wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
    499498                                                        % hal::from_utf8_safe(a.msg())) 
     
    504503                void operator()(libt::listen_succeeded_alert const& a) const 
    505504                { 
    506                         event().post(shared_ptr<EventDetail>( 
    507                                 new EventGeneral(Event::info, a.timestamp(), 
     505                        event_log.post(shared_ptr<EventDetail>( 
     506                                new EventGeneral(event_logger::info, a.timestamp(), 
    508507                                        wformat(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT)) 
    509508                                                % hal::from_utf8_safe(a.msg())) 
     
    515514                void operator()(libt::peer_blocked_alert const& a) const 
    516515                { 
    517                         event().post(shared_ptr<EventDetail>( 
    518                                 new EventGeneral(Event::debug, a.timestamp(), 
     516                        event_log.post(shared_ptr<EventDetail>( 
     517                                new EventGeneral(event_logger::debug, a.timestamp(), 
    519518                                        wformat(hal::app().res_wstr(HAL_IPFILTER_ALERT)) 
    520519                                                % hal::from_utf8_safe(a.ip.to_string()) 
     
    525524                void operator()(libt::alert const& a) const 
    526525                { 
    527                         event().post(shared_ptr<EventDetail>( 
     526                        event_log.post(shared_ptr<EventDetail>( 
    528527                                        new EventLibtorrent(lbtAlertToHalEvent(a.severity()),  
    529                                                 a.timestamp(), Event::unclassified, hal::from_utf8_safe(a.msg()))));             
     528                                                a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.msg()))));              
    530529                } 
    531530                 
     
    574573                        { 
    575574                                // These are logged as debug because they are rarely important to act on! 
    576                                 event().post(shared_ptr<EventDetail>(\ 
    577                                         new EventStdException(Event::debug, e, L"alertHandler"))); 
     575                                event_log.post(shared_ptr<EventDetail>(\ 
     576                                        new EventStdException(event_logger::debug, e, L"alertHandler"))); 
    578577                        } 
    579578                         
     
    581580                } 
    582581                 
    583                 timer_.expires_from_now(boost::posix_time::seconds(5)); 
     582                timer_.expires_from_now(boost::posix_time::seconds(2)); 
    584583                timer_.async_wait(bind(&bit_impl::alertHandler, this)); 
    585584                } 
     
    603602                catch(std::exception& e) 
    604603                { 
    605                         event().post(shared_ptr<EventDetail>(\ 
    606                                 new EventStdException(Event::critical, e, L"saveTorrentData"))); 
     604                        event_log.post(shared_ptr<EventDetail>(\ 
     605                                new EventStdException(event_logger::critical, e, L"saveTorrentData"))); 
    607606                } 
    608607        } 
     
    640639                theSession.set_max_half_open_connections(10); 
    641640                 
    642                 hal::event().post(shared_ptr<hal::EventDetail>( 
    643                         new hal::EventMsg(L"Loading BitTorrent.xml.", hal::Event::info)));               
     641                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     642                        new hal::EventMsg(L"Loading BitTorrent.xml.", hal::event_logger::info)));                
    644643                bittorrentIni.load_data(); 
    645                 hal::event().post(shared_ptr<hal::EventDetail>( 
    646                         new hal::EventMsg(L"Loading torrent parameters.", hal::Event::info)));   
     644                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     645                        new hal::EventMsg(L"Loading torrent parameters.", hal::event_logger::info)));    
    647646                theTorrents.load(); 
    648                 hal::event().post(shared_ptr<hal::EventDetail>( 
    649                         new hal::EventMsg(L"Loading done!", hal::Event::info))); 
     647                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     648                        new hal::EventMsg(L"Loading done!", hal::event_logger::info))); 
    650649                 
    651650                try 
     
    656655                        fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
    657656                 
    658                         event().post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
     657                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Loading old Torrents.xml"))); 
    659658                 
    660659                        TorrentMap torrents; 
     
    665664                        } 
    666665                         
    667                         event().post(shared_ptr<EventDetail>(new EventMsg( 
     666                        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    668667                                wformat(L"Total %1%.") % theTorrents.size())));                          
    669668                         
     
    673672                catch(const std::exception& e) 
    674673                { 
    675                         event().post(shared_ptr<EventDetail>( 
    676                                 new EventStdException(Event::fatal, e, L"Loading Old Torrents.xml"))); 
     674                        event_log.post(shared_ptr<EventDetail>( 
     675                                new EventStdException(event_logger::fatal, e, L"Loading Old Torrents.xml"))); 
    677676                }                
    678677                                 
     
    685684                        catch(const std::exception& e) 
    686685                        { 
    687                                 event().post(shared_ptr<EventDetail>( 
    688                                         new EventStdException(Event::critical, e, L"Loading DHTState.bin"))); 
     686                                event_log.post(shared_ptr<EventDetail>( 
     687                                        new EventStdException(event_logger::critical, e, L"Loading DHTState.bin"))); 
    689688                        } 
    690689                } 
     
    762761                                // User canceled torrent creation. 
    763762 
    764                                 hal::event().post(shared_ptr<hal::EventDetail>( 
    765                                         new hal::EventMsg(hal::app().res_wstr(HAL_NEWT_CREATION_CANCELED), hal::Event::info))); 
     763                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     764                                        new hal::EventMsg(hal::app().res_wstr(HAL_NEWT_CREATION_CANCELED), hal::event_logger::info))); 
    766765 
    767766                                return true; 
     
    780779                catch(const std::exception& e) 
    781780                { 
    782                         event().post(shared_ptr<EventDetail>( 
    783                                 new EventStdException(Event::fatal, e, L"create_torrent"))); 
     781                        event_log.post(shared_ptr<EventDetail>( 
     782                                new EventStdException(event_logger::fatal, e, L"create_torrent"))); 
    784783                }        
    785784 
     
    832831catch (const libt::invalid_handle&) \ 
    833832{\ 
    834         event().post(shared_ptr<EventDetail>( \ 
    835                 new EventInvalidTorrent(Event::critical, Event::invalidTorrent, name, std::string(FUNCTION)))); \ 
     833        event_log.post(shared_ptr<EventDetail>( \ 
     834                new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, name, std::string(FUNCTION)))); \ 
    836835}\ 
    837836catch (const invalidTorrent& t) \ 
    838837{\ 
    839         event().post(shared_ptr<EventDetail>( \ 
    840                 new EventInvalidTorrent(Event::info, Event::invalidTorrent, t.who(), std::string(FUNCTION)))); \ 
     838        event_log.post(shared_ptr<EventDetail>( \ 
     839                new EventInvalidTorrent(event_logger::info, event_logger::invalidTorrent, t.who(), std::string(FUNCTION)))); \ 
    841840}\ 
    842841catch (const std::exception& e) \ 
    843842{\ 
    844         event().post(shared_ptr<EventDetail>( \ 
    845                 new EventTorrentException(Event::critical, Event::torrentException, std::string(e.what()), name, std::string(FUNCTION)))); \ 
     843        event_log.post(shared_ptr<EventDetail>( \ 
     844                new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), name, std::string(FUNCTION)))); \ 
    846845} 
    847846 
     
    849848catch (const libt::invalid_handle&) \ 
    850849{\ 
    851         event().post(shared_ptr<EventDetail>( \ 
    852                 new EventInvalidTorrent(Event::critical, Event::invalidTorrent, TORRENT, std::string(FUNCTION)))); \ 
     850        event_log.post(shared_ptr<EventDetail>( \ 
     851                new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, TORRENT, std::string(FUNCTION)))); \ 
    853852}\ 
    854853catch (const invalidTorrent& t) \ 
    855854{\ 
    856         event().post(shared_ptr<EventDetail>( \ 
    857                 new EventInvalidTorrent(Event::info, Event::invalidTorrent, t.who(), std::string(FUNCTION)))); \ 
     855        event_log.post(shared_ptr<EventDetail>( \ 
     856                new EventInvalidTorrent(event_logger::info, event_logger::invalidTorrent, t.who(), std::string(FUNCTION)))); \ 
    858857}\ 
    859858catch (const std::exception& e) \ 
    860859{\ 
    861         event().post(shared_ptr<EventDetail>( \ 
    862                 new EventTorrentException(Event::critical, Event::torrentException, std::string(e.what()), TORRENT, std::string(FUNCTION)))); \ 
     860        event_log.post(shared_ptr<EventDetail>( \ 
     861                new EventTorrentException(event_logger::critical, event_logger::torrentException, std::string(e.what()), TORRENT, std::string(FUNCTION)))); \ 
    863862} 
    864863 
     
    909908        catch (const std::exception& e) 
    910909        { 
    911                 event().post(shared_ptr<EventDetail>( 
    912                         new EventStdException(Event::fatal, e, L"From bit::listenOn."))); 
     910                event_log.post(shared_ptr<EventDetail>( 
     911                        new EventStdException(event_logger::fatal, e, L"From bit::listenOn."))); 
    913912 
    914913                return false; 
     
    980979                if (mapping == mappingUPnP) 
    981980                { 
    982                         event().post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping."))); 
     981                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping."))); 
    983982                        pimpl->theSession.stop_upnp(); 
    984983                        pimpl->theSession.stop_natpmp(); 
     
    988987                else 
    989988                { 
    990                         event().post(shared_ptr<EventDetail>(new EventMsg(L"Starting NAT-PMP mapping."))); 
     989                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting NAT-PMP mapping."))); 
    991990                        pimpl->theSession.stop_upnp(); 
    992991                        pimpl->theSession.stop_natpmp(); 
     
    997996        else 
    998997        { 
    999                 event().post(shared_ptr<EventDetail>(new EventMsg(L"No mapping."))); 
     998                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"No mapping."))); 
    1000999                pimpl->theSession.stop_upnp(); 
    10011000                pimpl->theSession.stop_natpmp(); 
     
    10111010        pimpl->theSession.set_settings(settings); 
    10121011 
    1013         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1012        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    10141013                wformat(L"Set Timeouts, peer %1%, tracker %2%") % peers % tracker))); 
    10151014} 
     
    10201019        pimpl->theSession.set_max_connections(maxConn); 
    10211020         
    1022         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1021        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    10231022                wformat(L"Set connections totals %1% and uploads %2%.")  
    10241023                        % maxConn % maxUpload))); 
     
    10321031        pimpl->theSession.set_upload_rate_limit(up); 
    10331032         
    1034         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1033        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    10351034                wformat(L"Set session rates at download %1% and upload %2%.")  
    10361035                        % pimpl->theSession.download_rate_limit() % pimpl->theSession.upload_rate_limit()))); 
     
    11111110        catch(const std::exception& e) 
    11121111        {                
    1113                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    1114                         new hal::EventStdException(Event::critical, e, L"ensureIpFilterOn")));  
     1112                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     1113                        new hal::EventStdException(event_logger::critical, e, L"ensureIpFilterOn")));  
    11151114 
    11161115                ensureIpFilterOff(); 
    11171116        } 
    11181117 
    1119         event().post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));  
     1118        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));        
    11201119 
    11211120        return false; 
     
    11271126        pimpl->ip_filter_on_ = false; 
    11281127         
    1129         event().post(shared_ptr<EventDetail>(new EventMsg(L"IP filters off.")));         
     1128        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters off.")));       
    11301129} 
    11311130 
     
    11491148                        pe.allowed_enc_level = libt::pe_settings::both; 
    11501149                         
    1151                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1152                                 new hal::EventGeneral(hal::Event::warning, hal::Event::unclassified,  
     1150                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1151                                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    11531152                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str()))); 
    11541153        } 
     
    11681167                        pe.in_enc_policy = libt::pe_settings::enabled; 
    11691168                         
    1170                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1171                                 new hal::EventGeneral(hal::Event::warning, hal::Event::unclassified,  
     1169                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1170                                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    11721171                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    11731172        } 
     
    11871186                        pe.out_enc_policy = libt::pe_settings::enabled; 
    11881187                         
    1189                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1190                                 new hal::EventGeneral(hal::Event::warning, hal::Event::unclassified,  
     1188                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1189                                new hal::EventGeneral(hal::event_logger::warning, hal::event_logger::unclassified,  
    11911190                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    11921191        } 
     
    12021201        catch(const std::exception& e) 
    12031202        { 
    1204                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    1205                                 new hal::EventStdException(Event::critical, e, L"ensurePeOn")));  
     1203                hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     1204                                new hal::EventStdException(event_logger::critical, e, L"ensurePeOn")));  
    12061205                                 
    12071206                ensurePeOff();           
    12081207        } 
    12091208         
    1210         event().post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on."))); 
     1209        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on."))); 
    12111210} 
    12121211 
     
    12221221        pimpl->theSession.set_pe_settings(pe); 
    12231222 
    1224         event().post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off."))); 
     1223        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off."))); 
    12251224} 
    12261225#endif 
     
    13131312                                catch(...) 
    13141313                                { 
    1315                                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1316                                                 new hal::EventDebug(hal::Event::info,  
     1314                                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1315                                                new hal::EventDebug(hal::event_logger::info,  
    13171316                                                        from_utf8((format("Invalid IP range: %1%-%2%.") % first % last).str())))); 
    13181317                                } 
     
    13271326        catch(const std::exception& e) 
    13281327        { 
    1329                 event().post(shared_ptr<EventDetail>( 
    1330                         new EventStdException(Event::critical, e, L"ip_filter_import_dat"))); 
     1328                event_log.post(shared_ptr<EventDetail>( 
     1329                        new EventStdException(event_logger::critical, e, L"ip_filter_import_dat"))); 
    13311330        } 
    13321331 
     
    13581357        pimpl->theSession.set_max_half_open_connections(halfConn); 
    13591358 
    1360         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1359        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    13611360                wformat(L"Set half-open connections limit to %1%.") % pimpl->theSession.max_half_open_connections()))); 
    13621361} 
     
    13671366        pimpl->defTorrentMaxUpload_ = maxUpload; 
    13681367 
    1369         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1368        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    13701369                wformat(L"Set torrent connections total %1% and uploads %2%.") % maxConn % maxUpload))); 
    13711370 
     
    13731372        pimpl->defTorrentUpload_ = upload; 
    13741373 
    1375         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1374        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    13761375                wformat(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") % download % upload))); 
    13771376} 
     
    14061405                catch(std::exception &e)  
    14071406                {                
    1408                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    1409                                 new hal::EventStdException(Event::critical, e, L"prepTorrent, Resume")));  
     1407                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     1408                                new hal::EventStdException(event_logger::critical, e, L"prepTorrent, Resume")));  
    14101409         
    14111410                        fs::remove(resumeFile); 
     
    15181517        try { 
    15191518                 
    1520         event().post(shared_ptr<EventDetail>(new EventMsg(L"Resuming torrent."))); 
     1519        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Resuming torrent."))); 
    15211520         
    15221521        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e;) 
     
    15501549                        catch(const libt::duplicate_torrent&) 
    15511550                        { 
    1552                                 hal::event().post(shared_ptr<hal::EventDetail>( 
    1553                                         new hal::EventDebug(hal::Event::debug, L"Encountered duplicate torrent"))); 
     1551                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1552                                        new hal::EventDebug(hal::event_logger::debug, L"Encountered duplicate torrent"))); 
    15541553                                 
    15551554                                ++i; // Harmless, don't worry about it. 
     
    15571556                        catch(const std::exception& e)  
    15581557                        { 
    1559                                 hal::event().post(shared_ptr<hal::EventDetail>( 
    1560                                         new hal::EventStdException(hal::Event::warning, e, L"resumeAll"))); 
     1558                                hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1559                                        new hal::EventStdException(hal::event_logger::warning, e, L"resumeAll"))); 
    15611560                                 
    15621561                                pimpl->theTorrents.erase(i++); 
     
    15761575        try  
    15771576        {        
    1578         event().post(shared_ptr<EventDetail>(new EventInfo(L"Saving torrent data..."))); 
     1577        event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Saving torrent data..."))); 
    15791578 
    15801579        pimpl->saveTorrentData(); 
    15811580 
    1582         event().post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
     1581        event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
    15831582         
    15841583        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end();  
     
    16001599                } 
    16011600                 
    1602                 event().post(shared_ptr<EventDetail>(new EventInfo(wformat(L"%1% still active") % num_active))); 
     1601                event_log.post(shared_ptr<EventDetail>(new EventInfo(wformat(L"%1% still active") % num_active))); 
    16031602 
    16041603                if (fn) (*fn)(num_active); 
     
    16061605        } 
    16071606         
    1608         event().post(shared_ptr<EventDetail>(new EventInfo(L"All torrents stopped.")));          
    1609         event().post(shared_ptr<EventDetail>(new EventInfo(L"Fast-resume data written."))); 
     1607        event_log.post(shared_ptr<EventDetail>(new EventInfo(L"All torrents stopped.")));                
     1608        event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Fast-resume data written."))); 
    16101609         
    16111610        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "closeAll") 
     
    21432142void bit::stopEventReceiver() 
    21442143{ 
    2145         event().post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event Handler."))); 
     2144        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event Handler."))); 
    21462145 
    21472146        pimpl->stopAlertHandler(); 
  • trunk/src/halTorrentInternal.hpp

    r467 r478  
    145145                                filename += ".torrent"; 
    146146                 
    147                 event().post(shared_ptr<EventDetail>(new EventMsg( 
     147                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    148148                        wformat(L"Loaded names: %1%, %2%") % from_utf8(name) % from_utf8(filename)))); 
    149149 
     
    349349                                filename_ += L".torrent"; 
    350350                 
    351                 event().post(shared_ptr<EventDetail>(new EventMsg( 
     351                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    352352                        wformat(L"Loaded names: %1%, %2%") % name_ % filename_))); 
    353353        } 
     
    376376                catch(std::exception &e)  
    377377                {                
    378                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    379                                 new hal::EventStdException(Event::critical, e, L"updatePreVersion7Files")));  
     378                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     379                                new hal::EventStdException(event_logger::critical, e, L"updatePreVersion7Files")));  
    380380                } 
    381381        } 
     
    606606                catch(std::exception& e) 
    607607                { 
    608                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    609                                 new hal::EventStdException(Event::critical, e, L"addToSession")));  
     608                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     609                                new hal::EventStdException(event_logger::critical, e, L"addToSession")));  
    610610                } 
    611611        } 
     
    642642                catch(std::exception& e) 
    643643                { 
    644                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    645                                 new hal::EventStdException(Event::critical, e, L"removeFromSession")));  
     644                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
     645                                new hal::EventStdException(event_logger::critical, e, L"removeFromSession")));  
    646646                } 
    647647        } 
     
    11021102                const wpath torrentFile = workingDir_/L"torrents"/filename_; 
    11031103                 
    1104                 event().post(shared_ptr<EventDetail>(new EventMsg( 
     1104                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    11051105                        wformat(L"File: %1%, %2%.") % resumeFile % torrentFile))); 
    11061106                 
     
    11341134                                filename_ += L".torrent"; 
    11351135                 
    1136                 event().post(shared_ptr<EventDetail>(new EventMsg( 
     1136                event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    11371137                        wformat(L"Loaded names: %1%, %2%") % name_ % filename_))); 
    11381138        } 
     
    14421442                        torrent_internal_ptr TIp(new torrent_internal((*i).second)); 
    14431443                         
    1444                         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1444                        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    14451445                                wformat(L"Converting %1%.") % TIp->name()))); 
    14461446                         
     
    16581658        catch (const libt::invalid_handle&) 
    16591659        { 
    1660                 event().post(shared_ptr<EventDetail>( 
    1661                         new EventInvalidTorrent(Event::critical, Event::invalidTorrent, to_utf8(name_), "getTorrentDetail_ptr"))); 
     1660                event_log.post(shared_ptr<EventDetail>( 
     1661                        new EventInvalidTorrent(event_logger::critical, event_logger::invalidTorrent, to_utf8(name_), "getTorrentDetail_ptr"))); 
    16621662        } 
    16631663        catch (const std::exception& e) 
    16641664        { 
    1665                 event().post(shared_ptr<EventDetail>( 
    1666                         new EventTorrentException(Event::critical, Event::torrentException, e.what(), to_utf8(name_), "getTorrentDetail_ptr"))); 
     1665                event_log.post(shared_ptr<EventDetail>( 
     1666                        new EventTorrentException(event_logger::critical, event_logger::torrentException, e.what(), to_utf8(name_), "getTorrentDetail_ptr"))); 
    16671667        } 
    16681668         
Note: See TracChangeset for help on using the changeset viewer.