Changeset 476


Ignore:
Timestamp:
06/04/08 14:06:43 (12 years ago)
Author:
Eoin
Message:

Change seems ok.

Location:
branch_0_3_1
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • branch_0_3_1/sln/Halite/Halite.vcproj

    r475 r476  
    208208                                FavorSizeOrSpeed="2" 
    209209                                AdditionalIncludeDirectories=""$(SolutionDir)src";"$(SolutionDir)src\WTLx";"$(SolutionDir)lib\libtorrent\include";"$(SolutionDir)lib\libtorrent\zlib";"$(SolutionDir)lib\Asio\include";"$(SolutionDir)lib\OpenSSL\inc";"$(SolutionDir)lib\STLSoft\include"" 
    210                                 PreprocessorDefinitions="WIN32_LEAN_AND_MEAN;_WIN32_WINNT=0x0500;__USE_W32_SOCKETS;WIN32;_WIN32;_WINDOWS;NDEBUG;TORRENT_USE_BOOST_DATE_TIME;TORRENT_USE_OPENSSL;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS" 
     210                                PreprocessorDefinitions="WIN32_LEAN_AND_MEAN;_WIN32_WINNT=0x0500;__USE_W32_SOCKETS;WIN32;_WIN32;_WINDOWS;NDEBUG;TORRENT_USE_BOOST_DATE_TIME;TORRENT_USE_OPENSSL;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;_HAS_ITERATOR_DEBUGGING=0" 
    211211                                MinimalRebuild="true" 
    212212                                ExceptionHandling="2" 
  • branch_0_3_1/sln/libtorrent/libtorrent.vcproj

    r475 r476  
    176176                                FavorSizeOrSpeed="2" 
    177177                                AdditionalIncludeDirectories=""$(SolutionDir)lib\libtorrent\include";"$(SolutionDir)lib\libtorrent\zlib";"$(SolutionDir)lib\Asio\include\";"$(SolutionDir)lib\Openssl\inc"" 
    178                                 PreprocessorDefinitions="WIN32_LEAN_AND_MEAN;_WIN32_WINNT=0x0500;__USE_W32_SOCKETS;WIN32;_WIN32;_WINDOWS;NDEBUG;TORRENT_USE_BOOST_DATE_TIME;TORRENT_USE_OPENSSL;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS" 
     178                                PreprocessorDefinitions="WIN32_LEAN_AND_MEAN;_WIN32_WINNT=0x0500;__USE_W32_SOCKETS;WIN32;_WIN32;_WINDOWS;NDEBUG;TORRENT_USE_BOOST_DATE_TIME;TORRENT_USE_OPENSSL;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;_SECURE_SCL=0;_HAS_ITERATOR_DEBUGGING=0" 
    179179                                MinimalRebuild="true" 
    180180                                ExceptionHandling="2" 
  • branch_0_3_1/src/AdvHaliteDialog.cpp

    r387 r476  
    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 
  • branch_0_3_1/src/ConfigOptions.hpp

    r403 r476  
    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); 
  • branch_0_3_1/src/Halite.cpp

    r475 r476  
    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                         
     
    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 
    9494//      ::SetProcessAffinityMask(::GetCurrentProcess(), (DWORD_PTR)0x1); 
     
    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; 
  • branch_0_3_1/src/HaliteDialogBase.hpp

    r370 r476  
    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                } 
  • branch_0_3_1/src/HaliteListViewCtrl.hpp

    r390 r476  
    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) 
  • branch_0_3_1/src/HaliteWindow.cpp

    r474 r476  
    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} 
     
    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} 
     
    581581LRESULT HaliteWindow::OnAreYouMe(UINT, WPARAM, LPARAM, BOOL&)  
    582582{ 
    583         hal::event().post(shared_ptr<hal::EventDetail>( 
     583        hal::event_log.post(shared_ptr<hal::EventDetail>( 
    584584                new hal::EventMsg(L"I tried to contact me.")));          
    585585 
  • branch_0_3_1/src/NewTorrentDialog.cpp

    r472 r476  
    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        } 
  • branch_0_3_1/src/NewTorrentPeersLV.cpp

    r432 r476  
    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        } 
  • branch_0_3_1/src/WTLx/DdxEx.hpp

    r395 r476  
    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                                         
  • branch_0_3_1/src/WTLx/SelectionManager.hpp

    r423 r476  
    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 }; 
  • branch_0_3_1/src/advtabs/Debug.hpp

    r447 r476  
    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 
  • branch_0_3_1/src/advtabs/Files.cpp

    r456 r476  
    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(); 
  • branch_0_3_1/src/advtabs/Files.hpp

    r423 r476  
    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        } 
  • branch_0_3_1/src/halConfig.cpp

    r438 r476  
    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        } 
  • branch_0_3_1/src/halEvent.cpp

    r475 r476  
    4444        if (!s_event_impl) 
    4545                s_event_impl.reset(new event_impl()); 
     46 
     47        pimpl_ = s_event_impl; 
    4648} 
    4749 
     
    6163} 
    6264 
    63 void event_logger::log(boost::shared_ptr<EventDetail> e) 
     65void event_logger::post(boost::shared_ptr<EventDetail> e) 
    6466{ 
    6567        mutex_t::scoped_lock l(pimpl_->mutex_); 
    66         pimpl_->event_signal_(e); 
    67 } 
    68  
    69  
    70  
    71 void Event::post(boost::shared_ptr<EventDetail> event) 
    72 { 
    73         if (event->level() != hal::Event::debug || halite().logDebug()) 
    74                 signal(event); 
     68        if (e->level() != hal::event_logger::debug || halite().logDebug()) 
     69                pimpl_->event_signal_(e); 
    7570} 
    7671         
    77 std::wstring Event::eventLevelToStr(eventLevel event) 
     72std::wstring event_logger::eventLevelToStr(eventLevel event) 
    7873{ 
    7974        switch (event) 
     
    9489} 
    9590 
    96 Event& event() 
    97 { 
    98         static Event e; 
    99         return e; 
    100 } 
    101  
    10291} // namespace hal 
  • branch_0_3_1/src/halEvent.hpp

    r475 r476  
    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) 
     
    4747class event_logger : private boost::noncopyable 
    4848{        
    49 public: 
    50         event_logger(); 
    51         ~event_logger(); 
    52  
    53         bool is_active() { return pimpl_; } 
    54  
    55         boost::signals::connection attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn); 
    56         void dettach(const boost::signals::connection& c); 
    57  
    58         void log(boost::shared_ptr<EventDetail> e); 
    59  
    60 private: 
    61         std::vector<boost::signals::scoped_connection> connections_; 
    62         boost::shared_ptr<event_impl> pimpl_; 
    63 }; 
    64  
    65 #ifndef HAL_EVENT_IMPL_UNIT 
    66 static event_logger event_log; 
    67 #endif 
    68  
    69 class Event 
    70 { 
    71 public: 
     49public:  
    7250        enum eventLevel { dev, debug, info, warning, critical, fatal, none }; 
    7351         
     
    8765        }; 
    8866         
    89         static std::wstring eventLevelToStr(eventLevel);         
    90         void post(boost::shared_ptr<EventDetail> event); 
    91          
    92         boost::signals::connection attach(boost::function<void (boost::shared_ptr<EventDetail>)> fn) 
    93         { 
    94                 return event_signal_.connect(fn); 
    95         } 
    96  
    97         void signal(boost::shared_ptr<EventDetail> e) 
    98         { 
    99                 mutex_t::scoped_lock l(mutex_); 
    100  
    101                 event_signal_(e); 
    102         } 
    103          
    104 private: 
    105         mutable mutex_t mutex_; 
    106  
    107         boost::signal<void (boost::shared_ptr<EventDetail>)> event_signal_; 
    108 }; 
    109  
    110 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 
    11187 
    11288class EventDetail 
    11389{ 
    11490public: 
    115         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) : 
    11692                level_(l), 
    11793                timeStamp_(t), 
     
    126102        } 
    127103 
    128         Event::eventLevel level() { return level_; } 
     104        event_logger::eventLevel level() { return level_; } 
    129105        boost::posix_time::ptime timeStamp() { return timeStamp_; } 
    130         Event::codes code() { return code_; } 
     106        event_logger::codes code() { return code_; } 
    131107         
    132108private:         
    133         Event::eventLevel level_; 
     109        event_logger::eventLevel level_; 
    134110        boost::posix_time::ptime timeStamp_; 
    135         Event::codes code_; 
     111        event_logger::codes code_; 
    136112}; 
    137113 
     
    139115{ 
    140116public: 
    141         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) : 
    142118                EventDetail(l, t, c), 
    143119                msg_(m) 
     
    156132{ 
    157133public: 
    158         EventGeneral(Event::eventLevel l, Event::codes c, std::wstring m) : 
     134        EventGeneral(event_logger::eventLevel l, event_logger::codes c, std::wstring m) : 
    159135                EventDetail(l, boost::posix_time::second_clock::universal_time(), c), 
    160136                msg_(m) 
    161137        {} 
    162138         
    163         EventGeneral(Event::eventLevel l, boost::posix_time::ptime t, std::wstring m) : 
    164                 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), 
    165141                msg_(m) 
    166142        {} 
    167143         
    168144        template<typename str_t> 
    169         EventGeneral(Event::eventLevel l, str_t m) : 
    170                 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), 
    171147                msg_(hal::to_wstr_shim(m)) 
    172148        {} 
    173149         
    174150        template<typename str_t>         
    175         EventGeneral(Event::eventLevel l, boost::posix_time::ptime t, str_t m) : 
    176                 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), 
    177153                msg_(hal::to_wstr_shim(m)) 
    178154        {} 
     
    180156        virtual std::wstring msg() 
    181157        { 
    182                 if (Event::noEvent != code()) 
     158                if (event_logger::noEvent != code()) 
    183159                        return (boost::wformat(hal::app().res_wstr(code())) % msg_).str(); 
    184160                else 
     
    194170public: 
    195171        template<typename str_t> 
    196         EventMsg(str_t m, Event::eventLevel l=Event::debug,  
    197                 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) : 
    198174                EventDetail(l, t, c), 
    199175                msg_(hal::to_wstr_shim(m)) 
     
    202178        virtual std::wstring msg() 
    203179        { 
    204                 if (Event::noEvent != code()) 
     180                if (event_logger::noEvent != code()) 
    205181                        return (boost::wformat(hal::app().res_wstr(code())) % msg_).str(); 
    206182                else 
     
    215191{ 
    216192public: 
    217         EventPeerAlert(Event::eventLevel l, boost::posix_time::ptime t, std::wstring m) : 
    218                 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), 
    219195                msg_(m) 
    220196        {} 
     
    233209public: 
    234210        EventXmlException(std::wstring e, std::wstring m) : 
    235                 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), 
    236212                exp_(e), 
    237213                msg_(m) 
     
    252228public: 
    253229        template<typename t_str, typename f_str> 
    254         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) : 
    255231                EventDetail(l, boost::posix_time::second_clock::universal_time(), code), 
    256232                torrent_(hal::to_wstr_shim(t)), 
     
    273249public: 
    274250        template<typename e_str, typename t_str, typename f_str> 
    275         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) : 
    276252                EventDetail(l, boost::posix_time::second_clock::universal_time(), code), 
    277253                torrent_(hal::to_wstr_shim(t)), 
     
    294270{ 
    295271public: 
    296         EventStdException(Event::eventLevel l, const std::exception& e, std::wstring from) : 
    297                 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), 
    298274                exception_(hal::from_utf8(e.what())), 
    299275                from_(from) 
     
    313289{ 
    314290public: 
    315         EventDebug(Event::eventLevel l, std::wstring msg) : 
    316                 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), 
    317293                msg_(msg) 
    318294        {} 
     
    332308        template<typename T> 
    333309        EventInfo(T msg) : 
    334                 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), 
    335311                msg_(to_wstr_shim(msg)) 
    336312        {} 
  • branch_0_3_1/src/halIni.hpp

    r441 r476  
    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                } 
  • branch_0_3_1/src/halTorrent.cpp

    r475 r476  
    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} 
     
    303303                catch(std::exception& e) 
    304304                { 
    305                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    306                                 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")));  
    307307                } 
    308308        } 
     
    340340                void operator()(libt::torrent_finished_alert const& a) const 
    341341                { 
    342                         event().post(shared_ptr<EventDetail>( 
     342                        event_log.post(shared_ptr<EventDetail>( 
    343343                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
    344344                                                % get(a.handle)->name()),  
    345                                         Event::info, a.timestamp()))); 
     345                                        event_logger::info, a.timestamp()))); 
    346346                         
    347347                        get(a.handle)->finished();       
     
    350350                void operator()(libt::torrent_paused_alert const& a) const 
    351351                { 
    352                         event().post(shared_ptr<EventDetail>( 
     352                        event_log.post(shared_ptr<EventDetail>( 
    353353                                new EventMsg((wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
    354354                                                % get(a.handle)->name()),  
    355                                         Event::info, a.timestamp()))); 
     355                                        event_logger::info, a.timestamp()))); 
    356356 
    357357                        get(a.handle)->signals().torrent_paused(); 
     
    360360                void operator()(libt::peer_error_alert const& a) const 
    361361                { 
    362                         event().post(shared_ptr<EventDetail>( 
     362                        event_log.post(shared_ptr<EventDetail>( 
    363363                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    364364                                        wformat(hal::app().res_wstr(HAL_PEER_ALERT)) 
     
    370370                void operator()(libt::peer_ban_alert const& a) const 
    371371                { 
    372                         event().post(shared_ptr<EventDetail>( 
     372                        event_log.post(shared_ptr<EventDetail>( 
    373373                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    374374                                        wformat(hal::app().res_wstr(HAL_PEER_BAN_ALERT)) 
     
    380380                void operator()(libt::hash_failed_alert const& a) const 
    381381                { 
    382                         event().post(shared_ptr<EventDetail>( 
     382                        event_log.post(shared_ptr<EventDetail>( 
    383383                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    384384                                        wformat(hal::app().res_wstr(HAL_HASH_FAIL_ALERT)) 
     
    390390                void operator()(libt::url_seed_alert const& a) const 
    391391                { 
    392                         event().post(shared_ptr<EventDetail>( 
     392                        event_log.post(shared_ptr<EventDetail>( 
    393393                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    394394                                        wformat(hal::app().res_wstr(HAL_URL_SEED_ALERT)) 
     
    401401                void operator()(libt::tracker_warning_alert const& a) const 
    402402                { 
    403                         event().post(shared_ptr<EventDetail>( 
     403                        event_log.post(shared_ptr<EventDetail>( 
    404404                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    405405                                        wformat(hal::app().res_wstr(HAL_TRACKER_WARNING_ALERT)) 
     
    411411                void operator()(libt::tracker_announce_alert const& a) const 
    412412                { 
    413                         event().post(shared_ptr<EventDetail>( 
     413                        event_log.post(shared_ptr<EventDetail>( 
    414414                                new EventMsg((wformat(hal::app().res_wstr(HAL_TRACKER_ANNOUNCE_ALERT))  
    415415                                                % get(a.handle)->name()),  
    416                                         Event::info, a.timestamp()))); 
     416                                        event_logger::info, a.timestamp()))); 
    417417                } 
    418418                 
    419419                void operator()(libt::tracker_alert const& a) const 
    420420                { 
    421                         event().post(shared_ptr<EventDetail>( 
     421                        event_log.post(shared_ptr<EventDetail>( 
    422422                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    423423                                        wformat(hal::app().res_wstr(HAL_TRACKER_ALERT)) 
     
    431431                void operator()(libt::tracker_reply_alert const& a) const 
    432432                { 
    433                         event().post(shared_ptr<EventDetail>( 
     433                        event_log.post(shared_ptr<EventDetail>( 
    434434                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    435435                                        wformat(hal::app().res_wstr(HAL_TRACKER_REPLY_ALERT)) 
     
    442442                void operator()(libt::fastresume_rejected_alert const& a) const 
    443443                { 
    444                         event().post(shared_ptr<EventDetail>( 
     444                        event_log.post(shared_ptr<EventDetail>( 
    445445                                new EventGeneral(lbtAlertToHalEvent(a.severity()), a.timestamp(), 
    446446                                        wformat(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
     
    452452                void operator()(libt::piece_finished_alert const& a) const 
    453453                { 
    454                         event().post(shared_ptr<EventDetail>( 
    455                                 new EventGeneral(Event::debug, a.timestamp(), 
     454                        event_log.post(shared_ptr<EventDetail>( 
     455                                new EventGeneral(event_logger::debug, a.timestamp(), 
    456456                                        wformat(hal::app().res_wstr(HAL_PIECE_FINISHED_ALERT)) 
    457457                                                % get(a.handle)->name() 
     
    462462                void operator()(libt::block_finished_alert const& a) const 
    463463                { 
    464                         event().post(shared_ptr<EventDetail>( 
    465                                 new EventGeneral(Event::debug, a.timestamp(), 
     464                        event_log.post(shared_ptr<EventDetail>( 
     465                                new EventGeneral(event_logger::debug, a.timestamp(), 
    466466                                        wformat(hal::app().res_wstr(HAL_BLOCK_FINISHED_ALERT)) 
    467467                                                % get(a.handle)->name() 
     
    473473                void operator()(libt::block_downloading_alert const& a) const 
    474474                { 
    475                         event().post(shared_ptr<EventDetail>( 
    476                                 new EventGeneral(Event::debug, a.timestamp(), 
     475                        event_log.post(shared_ptr<EventDetail>( 
     476                                new EventGeneral(event_logger::debug, a.timestamp(), 
    477477                                        wformat(hal::app().res_wstr(HAL_BLOCK_DOWNLOADING_ALERT)) 
    478478                                                % get(a.handle)->name() 
     
    486486                        if (a.endpoint.address().is_v6()) 
    487487                        {        
    488                                 event().post(shared_ptr<EventDetail>( 
    489                                         new EventGeneral(Event::info, a.timestamp(), 
     488                                event_log.post(shared_ptr<EventDetail>( 
     489                                        new EventGeneral(event_logger::info, a.timestamp(), 
    490490                                                hal::app().res_wstr(HAL_LISTEN_V6_FAILED_ALERT)) 
    491491                                )       );               
     
    493493                        else 
    494494                        { 
    495                                 event().post(shared_ptr<EventDetail>( 
    496                                         new EventGeneral(Event::info, a.timestamp(), 
     495                                event_log.post(shared_ptr<EventDetail>( 
     496                                        new EventGeneral(event_logger::info, a.timestamp(), 
    497497                                                wformat(hal::app().res_wstr(HAL_LISTEN_FAILED_ALERT)) 
    498498                                                        % hal::from_utf8_safe(a.msg())) 
     
    503503                void operator()(libt::listen_succeeded_alert const& a) const 
    504504                { 
    505                         event().post(shared_ptr<EventDetail>( 
    506                                 new EventGeneral(Event::info, a.timestamp(), 
     505                        event_log.post(shared_ptr<EventDetail>( 
     506                                new EventGeneral(event_logger::info, a.timestamp(), 
    507507                                        wformat(hal::app().res_wstr(HAL_LISTEN_SUCCEEDED_ALERT)) 
    508508                                                % hal::from_utf8_safe(a.msg())) 
     
    514514                void operator()(libt::peer_blocked_alert const& a) const 
    515515                { 
    516                         event().post(shared_ptr<EventDetail>( 
    517                                 new EventGeneral(Event::debug, a.timestamp(), 
     516                        event_log.post(shared_ptr<EventDetail>( 
     517                                new EventGeneral(event_logger::debug, a.timestamp(), 
    518518                                        wformat(hal::app().res_wstr(HAL_IPFILTER_ALERT)) 
    519519                                                % hal::from_utf8_safe(a.ip.to_string()) 
     
    524524                void operator()(libt::alert const& a) const 
    525525                { 
    526                         event().post(shared_ptr<EventDetail>( 
     526                        event_log.post(shared_ptr<EventDetail>( 
    527527                                        new EventLibtorrent(lbtAlertToHalEvent(a.severity()),  
    528                                                 a.timestamp(), Event::unclassified, hal::from_utf8_safe(a.msg()))));             
     528                                                a.timestamp(), event_logger::unclassified, hal::from_utf8_safe(a.msg()))));              
    529529                } 
    530530                 
     
    573573                        { 
    574574                                // These are logged as debug because they are rarely important to act on! 
    575                                 event().post(shared_ptr<EventDetail>(\ 
    576                                         new EventStdException(Event::debug, e, L"alertHandler"))); 
     575                                event_log.post(shared_ptr<EventDetail>(\ 
     576                                        new EventStdException(event_logger::debug, e, L"alertHandler"))); 
    577577                        } 
    578578                         
     
    602602                catch(std::exception& e) 
    603603                { 
    604                         event().post(shared_ptr<EventDetail>(\ 
    605                                 new EventStdException(Event::critical, e, L"saveTorrentData"))); 
     604                        event_log.post(shared_ptr<EventDetail>(\ 
     605                                new EventStdException(event_logger::critical, e, L"saveTorrentData"))); 
    606606                } 
    607607        } 
     
    639639                theSession.set_max_half_open_connections(10); 
    640640                 
    641                 hal::event().post(shared_ptr<hal::EventDetail>( 
    642                         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)));                
    643643                bittorrentIni.load_data(); 
    644                 hal::event().post(shared_ptr<hal::EventDetail>( 
    645                         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)));    
    646646                theTorrents.load(); 
    647                 hal::event().post(shared_ptr<hal::EventDetail>( 
    648                         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))); 
    649649                 
    650650                try 
     
    655655                        fs::wifstream ifs(workingDirectory/L"Torrents.xml"); 
    656656                 
    657                         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"))); 
    658658                 
    659659                        TorrentMap torrents; 
     
    664664                        } 
    665665                         
    666                         event().post(shared_ptr<EventDetail>(new EventMsg( 
     666                        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    667667                                wformat(L"Total %1%.") % theTorrents.size())));                          
    668668                         
     
    672672                catch(const std::exception& e) 
    673673                { 
    674                         event().post(shared_ptr<EventDetail>( 
    675                                 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"))); 
    676676                }                
    677677                                 
     
    684684                        catch(const std::exception& e) 
    685685                        { 
    686                                 event().post(shared_ptr<EventDetail>( 
    687                                         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"))); 
    688688                        } 
    689689                } 
     
    761761                                // User canceled torrent creation. 
    762762 
    763                                 hal::event().post(shared_ptr<hal::EventDetail>( 
    764                                         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))); 
    765765 
    766766                                return true; 
     
    779779                catch(const std::exception& e) 
    780780                { 
    781                         event().post(shared_ptr<EventDetail>( 
    782                                 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"))); 
    783783                }        
    784784 
     
    831831catch (const libt::invalid_handle&) \ 
    832832{\ 
    833         event().post(shared_ptr<EventDetail>( \ 
    834                 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)))); \ 
    835835}\ 
    836836catch (const invalidTorrent& t) \ 
    837837{\ 
    838         event().post(shared_ptr<EventDetail>( \ 
    839                 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)))); \ 
    840840}\ 
    841841catch (const std::exception& e) \ 
    842842{\ 
    843         event().post(shared_ptr<EventDetail>( \ 
    844                 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)))); \ 
    845845} 
    846846 
     
    848848catch (const libt::invalid_handle&) \ 
    849849{\ 
    850         event().post(shared_ptr<EventDetail>( \ 
    851                 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)))); \ 
    852852}\ 
    853853catch (const invalidTorrent& t) \ 
    854854{\ 
    855         event().post(shared_ptr<EventDetail>( \ 
    856                 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)))); \ 
    857857}\ 
    858858catch (const std::exception& e) \ 
    859859{\ 
    860         event().post(shared_ptr<EventDetail>( \ 
    861                 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)))); \ 
    862862} 
    863863 
     
    908908        catch (const std::exception& e) 
    909909        { 
    910                 event().post(shared_ptr<EventDetail>( 
    911                         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."))); 
    912912 
    913913                return false; 
     
    979979                if (mapping == mappingUPnP) 
    980980                { 
    981                         event().post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping."))); 
     981                        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Starting UPnP mapping."))); 
    982982                        pimpl->theSession.stop_upnp(); 
    983983                        pimpl->theSession.stop_natpmp(); 
     
    987987                else 
    988988                { 
    989                         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."))); 
    990990                        pimpl->theSession.stop_upnp(); 
    991991                        pimpl->theSession.stop_natpmp(); 
     
    996996        else 
    997997        { 
    998                 event().post(shared_ptr<EventDetail>(new EventMsg(L"No mapping."))); 
     998                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"No mapping."))); 
    999999                pimpl->theSession.stop_upnp(); 
    10001000                pimpl->theSession.stop_natpmp(); 
     
    10101010        pimpl->theSession.set_settings(settings); 
    10111011 
    1012         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1012        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    10131013                wformat(L"Set Timeouts, peer %1%, tracker %2%") % peers % tracker))); 
    10141014} 
     
    10191019        pimpl->theSession.set_max_connections(maxConn); 
    10201020         
    1021         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1021        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    10221022                wformat(L"Set connections totals %1% and uploads %2%.")  
    10231023                        % maxConn % maxUpload))); 
     
    10311031        pimpl->theSession.set_upload_rate_limit(up); 
    10321032         
    1033         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1033        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    10341034                wformat(L"Set session rates at download %1% and upload %2%.")  
    10351035                        % pimpl->theSession.download_rate_limit() % pimpl->theSession.upload_rate_limit()))); 
     
    11101110        catch(const std::exception& e) 
    11111111        {                
    1112                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    1113                         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")));  
    11141114 
    11151115                ensureIpFilterOff(); 
    11161116        } 
    11171117 
    1118         event().post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));  
     1118        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters on.")));        
    11191119 
    11201120        return false; 
     
    11261126        pimpl->ip_filter_on_ = false; 
    11271127         
    1128         event().post(shared_ptr<EventDetail>(new EventMsg(L"IP filters off.")));         
     1128        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"IP filters off.")));       
    11291129} 
    11301130 
     
    11481148                        pe.allowed_enc_level = libt::pe_settings::both; 
    11491149                         
    1150                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1151                                 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,  
    11521152                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_ENCODING_LEVEL)) % enc_level).str()))); 
    11531153        } 
     
    11671167                        pe.in_enc_policy = libt::pe_settings::enabled; 
    11681168                         
    1169                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1170                                 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,  
    11711171                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    11721172        } 
     
    11861186                        pe.out_enc_policy = libt::pe_settings::enabled; 
    11871187                         
    1188                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1189                                 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,  
    11901190                                        (wformat(hal::app().res_wstr(HAL_INCORRECT_CONNECT_POLICY)) % in_enc_policy).str()))); 
    11911191        } 
     
    12011201        catch(const std::exception& e) 
    12021202        { 
    1203                 hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    1204                                 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")));  
    12051205                                 
    12061206                ensurePeOff();           
    12071207        } 
    12081208         
    1209         event().post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on."))); 
     1209        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption on."))); 
    12101210} 
    12111211 
     
    12211221        pimpl->theSession.set_pe_settings(pe); 
    12221222 
    1223         event().post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off."))); 
     1223        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Protocol encryption off."))); 
    12241224} 
    12251225#endif 
     
    13121312                                catch(...) 
    13131313                                { 
    1314                                         hal::event().post(shared_ptr<hal::EventDetail>( 
    1315                                                 new hal::EventDebug(hal::Event::info,  
     1314                                        hal::event_log.post(shared_ptr<hal::EventDetail>( 
     1315                                                new hal::EventDebug(hal::event_logger::info,  
    13161316                                                        from_utf8((format("Invalid IP range: %1%-%2%.") % first % last).str())))); 
    13171317                                } 
     
    13261326        catch(const std::exception& e) 
    13271327        { 
    1328                 event().post(shared_ptr<EventDetail>( 
    1329                         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"))); 
    13301330        } 
    13311331 
     
    13571357        pimpl->theSession.set_max_half_open_connections(halfConn); 
    13581358 
    1359         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1359        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    13601360                wformat(L"Set half-open connections limit to %1%.") % pimpl->theSession.max_half_open_connections()))); 
    13611361} 
     
    13661366        pimpl->defTorrentMaxUpload_ = maxUpload; 
    13671367 
    1368         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1368        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    13691369                wformat(L"Set torrent connections total %1% and uploads %2%.") % maxConn % maxUpload))); 
    13701370 
     
    13721372        pimpl->defTorrentUpload_ = upload; 
    13731373 
    1374         event().post(shared_ptr<EventDetail>(new EventMsg( 
     1374        event_log.post(shared_ptr<EventDetail>(new EventMsg( 
    13751375                wformat(L"Set torrent default rates at %1$.2fkb/s down and %2$.2fkb/s upload.") % download % upload))); 
    13761376} 
     
    14051405                catch(std::exception &e)  
    14061406                {                
    1407                         hal::event().post(boost::shared_ptr<hal::EventDetail>( 
    1408                                 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")));  
    14091409         
    14101410                        fs::remove(resumeFile); 
     
    15171517        try { 
    15181518                 
    1519         event().post(shared_ptr<EventDetail>(new EventMsg(L"Resuming torrent."))); 
     1519        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Resuming torrent."))); 
    15201520         
    15211521        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); i != e;) 
     
    15491549                        catch(const libt::duplicate_torrent&) 
    15501550                        { 
    1551                                 hal::event().post(shared_ptr<hal::EventDetail>( 
    1552                                         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"))); 
    15531553                                 
    15541554                                ++i; // Harmless, don't worry about it. 
     
    15561556                        catch(const std::exception& e)  
    15571557                        { 
    1558                                 hal::event().post(shared_ptr<hal::EventDetail>( 
    1559                                         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"))); 
    15601560                                 
    15611561                                pimpl->theTorrents.erase(i++); 
     
    15751575        try  
    15761576        {        
    1577         event().post(shared_ptr<EventDetail>(new EventInfo(L"Saving torrent data..."))); 
     1577        event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Saving torrent data..."))); 
    15781578 
    15791579        pimpl->saveTorrentData(); 
    15801580 
    1581         event().post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
     1581        event_log.post(shared_ptr<EventDetail>(new EventInfo(L"Stopping all torrents..."))); 
    15821582         
    15831583        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end();  
     
    15991599                } 
    16001600                 
    1601                 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))); 
    16021602 
    16031603                if (fn) (*fn)(num_active); 
     
    16051605        } 
    16061606         
    1607         event().post(shared_ptr<EventDetail>(new EventInfo(L"All torrents stopped.")));          
    1608         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."))); 
    16091609         
    16101610        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH("Torrent Unknown!", "closeAll") 
     
    21422142void bit::stopEventReceiver() 
    21432143{ 
    2144         event().post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event Handler."))); 
     2144        event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Stopping event Handler."))); 
    21452145 
    21462146        pimpl->stopAlertHandler(); 
  • branch_0_3_1/src/halTorrentInternal.hpp

    r467 r476  
    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.