src/generic/logg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/logg.cpp
   3 // Purpose:     wxLog-derived classes which need GUI support (the rest is in
   4 //              src/common/log.cpp)
   5 // Author:      Vadim Zeitlin
   6 // Modified by:
   7 // Created:     20.09.99 (extracted from src/common/log.cpp)
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25     #pragma hdrstop
  26 #endif
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/app.h"
  30     #include "wx/button.h"
  31     #include "wx/intl.h"
  32     #include "wx/log.h"
  33     #include "wx/menu.h"
  34     #include "wx/frame.h"
  35     #include "wx/filedlg.h"
  36     #include "wx/msgdlg.h"
  37     #include "wx/textctrl.h"
  38     #include "wx/sizer.h"
  39     #include "wx/statbmp.h"
  40     #include "wx/settings.h"
  41     #include "wx/wxcrtvararg.h"
  42 #endif // WX_PRECOMP
  43
  44 #if wxUSE_LOGGUI || wxUSE_LOGWINDOW
  45
  46 #include "wx/file.h"
  47 #include "wx/clipbrd.h"
  48 #include "wx/dataobj.h"
  49 #include "wx/textfile.h"
  50 #include "wx/statline.h"
  51 #include "wx/artprov.h"
  52 #include "wx/collpane.h"
  53 #include "wx/arrstr.h"
  54
  55 #if wxUSE_THREADS
  56     #include "wx/thread.h"
  57 #endif // wxUSE_THREADS
  58
  59 #ifdef  __WXMSW__
  60     // for OutputDebugString()
  61     #include  "wx/msw/private.h"
  62 #endif // Windows
  63
  64
  65 #ifdef  __WXPM__
  66     #include <time.h>
  67 #endif
  68
  69 #if wxUSE_LOG_DIALOG
  70     #include "wx/listctrl.h"
  71     #include "wx/imaglist.h"
  72     #include "wx/image.h"
  73 #endif // wxUSE_LOG_DIALOG/!wxUSE_LOG_DIALOG
  74
  75 #if defined(__MWERKS__) && wxUSE_UNICODE
  76     #include <wtime.h>
  77 #endif
  78
  79 #include "wx/datetime.h"
  80
  81 // the suffix we add to the button to show that the dialog can be expanded
  82 #define EXPAND_SUFFIX _T(" >>")
  83
  84 #define CAN_SAVE_FILES (wxUSE_FILE && wxUSE_FILEDLG)
  85
  86 // ----------------------------------------------------------------------------
  87 // private classes
  88 // ----------------------------------------------------------------------------
  89
  90 #if wxUSE_LOG_DIALOG
  91
  92 // this function is a wrapper around strftime(3)
  93 // allows to exclude the usage of wxDateTime
  94 static wxString TimeStamp(const wxString& format, time_t t)
  95 {
  96 #if wxUSE_DATETIME
  97     wxChar buf[4096];
  98     struct tm tm;
  99     if ( !wxStrftime(buf, WXSIZEOF(buf), format, wxLocaltime_r(&t, &tm)) )
 100     {
 101         // buffer is too small?
 102         wxFAIL_MSG(_T("strftime() failed"));
 103     }
 104     return wxString(buf);
 105 #else // !wxUSE_DATETIME
 106     return wxEmptyString;
 107 #endif // wxUSE_DATETIME/!wxUSE_DATETIME
 108 }
 109
 110
 111 class wxLogDialog : public wxDialog
 112 {
 113 public:
 114     wxLogDialog(wxWindow *parent,
 115                 const wxArrayString& messages,
 116                 const wxArrayInt& severity,
 117                 const wxArrayLong& timess,
 118                 const wxString& caption,
 119                 long style);
 120     virtual ~wxLogDialog();
 121
 122     // event handlers
 123     void OnOk(wxCommandEvent& event);
 124 #if wxUSE_CLIPBOARD
 125     void OnCopy(wxCommandEvent& event);
 126 #endif // wxUSE_CLIPBOARD
 127 #if CAN_SAVE_FILES
 128     void OnSave(wxCommandEvent& event);
 129 #endif // CAN_SAVE_FILES
 130     void OnListSelect(wxListEvent& event);
 131     void OnListItemActivated(wxListEvent& event);
 132
 133 private:
 134     // create controls needed for the details display
 135     void CreateDetailsControls(wxWindow *);
 136
 137     // if necessary truncates the given string and adds an ellipsis
 138     wxString EllipsizeString(const wxString &text)
 139     {
 140         if (ms_maxLength > 0 &&
 141             text.length() > ms_maxLength)
 142         {
 143             wxString ret(text);
 144             ret.Truncate(ms_maxLength);
 145             ret << "...";
 146             return ret;
 147         }
 148
 149         return text;
 150     }
 151
 152 #if CAN_SAVE_FILES || wxUSE_CLIPBOARD
 153     // return the contents of the dialog as a multiline string
 154     wxString GetLogMessages() const;
 155 #endif // CAN_SAVE_FILES || wxUSE_CLIPBOARD
 156
 157
 158     // the data for the listctrl
 159     wxArrayString m_messages;
 160     wxArrayInt m_severity;
 161     wxArrayLong m_times;
 162
 163     // the controls which are not shown initially (but only when details
 164     // button is pressed)
 165     wxListCtrl *m_listctrl;
 166
 167     // the translated "Details" string
 168     static wxString ms_details;
 169
 170     // the maximum length of the log message
 171     static size_t ms_maxLength;
 172
 173     DECLARE_EVENT_TABLE()
 174     DECLARE_NO_COPY_CLASS(wxLogDialog)
 175 };
 176
 177 BEGIN_EVENT_TABLE(wxLogDialog, wxDialog)
 178     EVT_BUTTON(wxID_OK, wxLogDialog::OnOk)
 179 #if wxUSE_CLIPBOARD
 180     EVT_BUTTON(wxID_COPY,   wxLogDialog::OnCopy)
 181 #endif // wxUSE_CLIPBOARD
 182 #if CAN_SAVE_FILES
 183     EVT_BUTTON(wxID_SAVE,   wxLogDialog::OnSave)
 184 #endif // CAN_SAVE_FILES
 185     EVT_LIST_ITEM_SELECTED(wxID_ANY, wxLogDialog::OnListSelect)
 186     EVT_LIST_ITEM_ACTIVATED(wxID_ANY, wxLogDialog::OnListItemActivated)
 187 END_EVENT_TABLE()
 188
 189 #endif // wxUSE_LOG_DIALOG
 190
 191 // ----------------------------------------------------------------------------
 192 // private functions
 193 // ----------------------------------------------------------------------------
 194
 195 #if CAN_SAVE_FILES
 196
 197 // pass an uninitialized file object, the function will ask the user for the
 198 // filename and try to open it, returns true on success (file was opened),
 199 // false if file couldn't be opened/created and -1 if the file selection
 200 // dialog was cancelled
 201 static int OpenLogFile(wxFile& file, wxString *filename = NULL, wxWindow *parent = NULL);
 202
 203 #endif // CAN_SAVE_FILES
 204
 205 // ----------------------------------------------------------------------------
 206 // global variables
 207 // ----------------------------------------------------------------------------
 208
 209 // we use a global variable to store the frame pointer for wxLogStatus - bad,
 210 // but it's the easiest way
 211 static wxFrame *gs_pFrame = NULL; // FIXME MT-unsafe
 212
 213 // ============================================================================
 214 // implementation
 215 // ============================================================================
 216
 217 // ----------------------------------------------------------------------------
 218 // global functions
 219 // ----------------------------------------------------------------------------
 220
 221 // accepts an additional argument which tells to which frame the output should
 222 // be directed
 223 void wxVLogStatus(wxFrame *pFrame, const wxString& format, va_list argptr)
 224 {
 225   wxString msg;
 226
 227   wxLog *pLog = wxLog::GetActiveTarget();
 228   if ( pLog != NULL ) {
 229     msg.PrintfV(format, argptr);
 230
 231     wxASSERT( gs_pFrame == NULL ); // should be reset!
 232     gs_pFrame = pFrame;
 233 #ifdef __WXWINCE__
 234     wxLog::OnLog(wxLOG_Status, msg, 0);
 235 #else
 236     wxLog::OnLog(wxLOG_Status, msg, time(NULL));
 237 #endif
 238     gs_pFrame = NULL;
 239   }
 240 }
 241
 242 #if !wxUSE_UTF8_LOCALE_ONLY
 243 void wxDoLogStatusWchar(wxFrame *pFrame, const wxChar *format, ...)
 244 {
 245     va_list argptr;
 246     va_start(argptr, format);
 247     wxVLogStatus(pFrame, format, argptr);
 248     va_end(argptr);
 249 }
 250 #endif // !wxUSE_UTF8_LOCALE_ONLY
 251
 252 #if wxUSE_UNICODE_UTF8
 253 void wxDoLogStatusUtf8(wxFrame *pFrame, const char *format, ...)
 254 {
 255     va_list argptr;
 256     va_start(argptr, format);
 257     wxVLogStatus(pFrame, format, argptr);
 258     va_end(argptr);
 259 }
 260 #endif // wxUSE_UNICODE_UTF8
 261
 262 // ----------------------------------------------------------------------------
 263 // wxLogGui implementation (FIXME MT-unsafe)
 264 // ----------------------------------------------------------------------------
 265
 266 #if wxUSE_LOGGUI
 267
 268 wxLogGui::wxLogGui()
 269 {
 270     Clear();
 271 }
 272
 273 void wxLogGui::Clear()
 274 {
 275     m_bErrors =
 276     m_bWarnings =
 277     m_bHasMessages = false;
 278
 279     m_aMessages.Empty();
 280     m_aSeverity.Empty();
 281     m_aTimes.Empty();
 282 }
 283
 284 int wxLogGui::GetSeverityIcon() const
 285 {
 286     return m_bErrors ? wxICON_STOP
 287                      : m_bWarnings ? wxICON_EXCLAMATION
 288                                    : wxICON_INFORMATION;
 289 }
 290
 291 wxString wxLogGui::GetTitle() const
 292 {
 293     wxString titleFormat;
 294     switch ( GetSeverityIcon() )
 295     {
 296         case wxICON_STOP:
 297             titleFormat = _("%s Error");
 298             break;
 299
 300         case wxICON_EXCLAMATION:
 301             titleFormat = _("%s Warning");
 302             break;
 303
 304         default:
 305             wxFAIL_MSG( "unexpected icon severity" );
 306             // fall through
 307
 308         case wxICON_INFORMATION:
 309             titleFormat = _("%s Information");
 310     }
 311
 312     return wxString::Format(titleFormat, wxTheApp->GetAppDisplayName());
 313 }
 314
 315 void
 316 wxLogGui::DoShowSingleLogMessage(const wxString& message,
 317                                  const wxString& title,
 318                                  int style)
 319 {
 320     wxMessageBox(message, title, wxOK | style);
 321 }
 322
 323 void
 324 wxLogGui::DoShowMultipleLogMessages(const wxArrayString& messages,
 325                                     const wxArrayInt& severities,
 326                                     const wxArrayLong& times,
 327                                     const wxString& title,
 328                                     int style)
 329 {
 330 #if wxUSE_LOG_DIALOG
 331     wxLogDialog dlg(NULL,
 332                     messages, severities, times,
 333                     title, style);
 334
 335     // clear the message list before showing the dialog because while it's
 336     // shown some new messages may appear
 337     Clear();
 338
 339     (void)dlg.ShowModal();
 340 #else // !wxUSE_LOG_DIALOG
 341     // start from the most recent message
 342     wxString message;
 343     str.reserve(nMsgCount*100);
 344     for ( size_t n = nMsgCount; n > 0; n-- ) {
 345         message << m_aMessages[n - 1] << wxT("\n");
 346     }
 347
 348     DoShowSingleLogMessage(message, title, style);
 349 #endif // wxUSE_LOG_DIALOG/!wxUSE_LOG_DIALOG
 350 }
 351
 352 void wxLogGui::Flush()
 353 {
 354     if ( !m_bHasMessages )
 355         return;
 356
 357     // do it right now to block any new calls to Flush() while we're here
 358     m_bHasMessages = false;
 359
 360     // note that this must be done before examining m_aMessages as it may log
 361     // yet another message
 362     const unsigned repeatCount = LogLastRepeatIfNeeded();
 363
 364     const size_t nMsgCount = m_aMessages.size();
 365
 366     if ( repeatCount > 0 )
 367     {
 368         m_aMessages[nMsgCount - 1] << " (" << m_aMessages[nMsgCount - 2] << ")";
 369     }
 370
 371     const wxString title = GetTitle();
 372     const int style = GetSeverityIcon();
 373
 374     // avoid showing other log dialogs until we're done with the dialog we're
 375     // showing right now: nested modal dialogs make for really bad UI!
 376     Suspend();
 377
 378     if ( nMsgCount == 1 )
 379     {
 380         // make a copy before calling Clear()
 381         const wxString message(m_aMessages[0]);
 382         Clear();
 383
 384         DoShowSingleLogMessage(message, title, style);
 385     }
 386     else // more than one message
 387     {
 388         wxArrayString messages;
 389         wxArrayInt severities;
 390         wxArrayLong times;
 391
 392         messages.swap(m_aMessages);
 393         severities.swap(m_aSeverity);
 394         times.swap(m_aTimes);
 395
 396         Clear();
 397
 398         DoShowMultipleLogMessages(messages, severities, times, title, style);
 399     }
 400
 401     // allow flushing the logs again
 402     Resume();
 403 }
 404
 405 // log all kinds of messages
 406 void wxLogGui::DoLog(wxLogLevel level, const wxString& szString, time_t t)
 407 {
 408     switch ( level ) {
 409         case wxLOG_Info:
 410             if ( GetVerbose() )
 411         case wxLOG_Message:
 412             {
 413                 m_aMessages.Add(szString);
 414                 m_aSeverity.Add(wxLOG_Message);
 415                 m_aTimes.Add((long)t);
 416                 m_bHasMessages = true;
 417             }
 418             break;
 419
 420         case wxLOG_Status:
 421 #if wxUSE_STATUSBAR
 422             {
 423                 // find the top window and set it's status text if it has any
 424                 wxFrame *pFrame = gs_pFrame;
 425                 if ( pFrame == NULL ) {
 426                     wxWindow *pWin = wxTheApp->GetTopWindow();
 427                     if ( pWin != NULL && pWin->IsKindOf(CLASSINFO(wxFrame)) ) {
 428                         pFrame = (wxFrame *)pWin;
 429                     }
 430                 }
 431
 432                 if ( pFrame && pFrame->GetStatusBar() )
 433                     pFrame->SetStatusText(szString);
 434             }
 435 #endif // wxUSE_STATUSBAR
 436             break;
 437
 438         case wxLOG_Trace:
 439         case wxLOG_Debug:
 440             #ifdef __WXDEBUG__
 441             {
 442                 wxString str;
 443                 TimeStamp(&str);
 444                 str += szString;
 445
 446                 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 447                     // don't prepend debug/trace here: it goes to the
 448                     // debug window anyhow
 449                     str += wxT("\r\n");
 450                     OutputDebugString(str.wx_str());
 451                 #else
 452                     // send them to stderr
 453                     wxFprintf(stderr, wxT("[%s] %s\n"),
 454                               level == wxLOG_Trace ? wxT("Trace")
 455                                                    : wxT("Debug"),
 456                               str.c_str());
 457                     fflush(stderr);
 458                 #endif
 459             }
 460             #endif // __WXDEBUG__
 461
 462             break;
 463
 464         case wxLOG_FatalError:
 465             // show this one immediately
 466             wxMessageBox(szString, _("Fatal error"), wxICON_HAND);
 467             wxExit();
 468             break;
 469
 470         case wxLOG_Error:
 471             if ( !m_bErrors ) {
 472 #if !wxUSE_LOG_DIALOG
 473                 // discard earlier informational messages if this is the 1st
 474                 // error because they might not make sense any more and showing
 475                 // them in a message box might be confusing
 476                 m_aMessages.Empty();
 477                 m_aSeverity.Empty();
 478                 m_aTimes.Empty();
 479 #endif // wxUSE_LOG_DIALOG
 480                 m_bErrors = true;
 481             }
 482             // fall through
 483
 484         case wxLOG_Warning:
 485             if ( !m_bErrors ) {
 486                 // for the warning we don't discard the info messages
 487                 m_bWarnings = true;
 488             }
 489
 490             m_aMessages.Add(szString);
 491             m_aSeverity.Add((int)level);
 492             m_aTimes.Add((long)t);
 493             m_bHasMessages = true;
 494             break;
 495     }
 496 }
 497
 498 #endif   // wxUSE_LOGGUI
 499
 500 // ----------------------------------------------------------------------------
 501 // wxLogWindow and wxLogFrame implementation
 502 // ----------------------------------------------------------------------------
 503
 504 #if wxUSE_LOGWINDOW
 505
 506 // log frame class
 507 // ---------------
 508 class wxLogFrame : public wxFrame
 509 {
 510 public:
 511     // ctor & dtor
 512     wxLogFrame(wxWindow *pParent, wxLogWindow *log, const wxString& szTitle);
 513     virtual ~wxLogFrame();
 514
 515     // menu callbacks
 516     void OnClose(wxCommandEvent& event);
 517     void OnCloseWindow(wxCloseEvent& event);
 518 #if CAN_SAVE_FILES
 519     void OnSave(wxCommandEvent& event);
 520 #endif // CAN_SAVE_FILES
 521     void OnClear(wxCommandEvent& event);
 522
 523     // this function is safe to call from any thread (notice that it should be
 524     // also called from the main thread to ensure that the messages logged from
 525     // it appear in correct order with the messages from the other threads)
 526     void AddLogMessage(const wxString& message);
 527
 528     // actually append the messages logged from secondary threads to the text
 529     // control during idle time in the main thread
 530     virtual void OnInternalIdle();
 531
 532 private:
 533     // use standard ids for our commands!
 534     enum
 535     {
 536         Menu_Close = wxID_CLOSE,
 537         Menu_Save  = wxID_SAVE,
 538         Menu_Clear = wxID_CLEAR
 539     };
 540
 541     // common part of OnClose() and OnCloseWindow()
 542     void DoClose();
 543
 544     // do show the message in the text control
 545     void DoShowLogMessage(const wxString& message)
 546     {
 547         m_pTextCtrl->AppendText(message);
 548     }
 549
 550     wxTextCtrl  *m_pTextCtrl;
 551     wxLogWindow *m_log;
 552
 553     // queue of messages logged from other threads which need to be displayed
 554     wxArrayString m_pendingMessages;
 555
 556 #if wxUSE_THREADS
 557     // critical section to protect access to m_pendingMessages
 558     wxCriticalSection m_critSection;
 559 #endif // wxUSE_THREADS
 560
 561
 562     DECLARE_EVENT_TABLE()
 563     DECLARE_NO_COPY_CLASS(wxLogFrame)
 564 };
 565
 566 BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
 567     // wxLogWindow menu events
 568     EVT_MENU(Menu_Close, wxLogFrame::OnClose)
 569 #if CAN_SAVE_FILES
 570     EVT_MENU(Menu_Save,  wxLogFrame::OnSave)
 571 #endif // CAN_SAVE_FILES
 572     EVT_MENU(Menu_Clear, wxLogFrame::OnClear)
 573
 574     EVT_CLOSE(wxLogFrame::OnCloseWindow)
 575 END_EVENT_TABLE()
 576
 577 wxLogFrame::wxLogFrame(wxWindow *pParent, wxLogWindow *log, const wxString& szTitle)
 578           : wxFrame(pParent, wxID_ANY, szTitle)
 579 {
 580     m_log = log;
 581
 582     m_pTextCtrl = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition,
 583             wxDefaultSize,
 584             wxTE_MULTILINE  |
 585             wxHSCROLL       |
 586             // needed for Win32 to avoid 65Kb limit but it doesn't work well
 587             // when using RichEdit 2.0 which we always do in the Unicode build
 588 #if !wxUSE_UNICODE
 589             wxTE_RICH       |
 590 #endif // !wxUSE_UNICODE
 591             wxTE_READONLY);
 592
 593 #if wxUSE_MENUS
 594     // create menu
 595     wxMenuBar *pMenuBar = new wxMenuBar;
 596     wxMenu *pMenu = new wxMenu;
 597 #if CAN_SAVE_FILES
 598     pMenu->Append(Menu_Save,  _("&Save..."), _("Save log contents to file"));
 599 #endif // CAN_SAVE_FILES
 600     pMenu->Append(Menu_Clear, _("C&lear"), _("Clear the log contents"));
 601     pMenu->AppendSeparator();
 602     pMenu->Append(Menu_Close, _("&Close"), _("Close this window"));
 603     pMenuBar->Append(pMenu, _("&Log"));
 604     SetMenuBar(pMenuBar);
 605 #endif // wxUSE_MENUS
 606
 607 #if wxUSE_STATUSBAR
 608     // status bar for menu prompts
 609     CreateStatusBar();
 610 #endif // wxUSE_STATUSBAR
 611
 612     m_log->OnFrameCreate(this);
 613 }
 614
 615 void wxLogFrame::DoClose()
 616 {
 617     if ( m_log->OnFrameClose(this) )
 618     {
 619         // instead of closing just hide the window to be able to Show() it
 620         // later
 621         Show(false);
 622     }
 623 }
 624
 625 void wxLogFrame::OnClose(wxCommandEvent& WXUNUSED(event))
 626 {
 627     DoClose();
 628 }
 629
 630 void wxLogFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 631 {
 632     DoClose();
 633 }
 634
 635 #if CAN_SAVE_FILES
 636 void wxLogFrame::OnSave(wxCommandEvent& WXUNUSED(event))
 637 {
 638     wxString filename;
 639     wxFile file;
 640     int rc = OpenLogFile(file, &filename, this);
 641     if ( rc == -1 )
 642     {
 643         // cancelled
 644         return;
 645     }
 646
 647     bool bOk = rc != 0;
 648
 649     // retrieve text and save it
 650     // -------------------------
 651     int nLines = m_pTextCtrl->GetNumberOfLines();
 652     for ( int nLine = 0; bOk && nLine < nLines; nLine++ ) {
 653         bOk = file.Write(m_pTextCtrl->GetLineText(nLine) +
 654                          wxTextFile::GetEOL());
 655     }
 656
 657     if ( bOk )
 658         bOk = file.Close();
 659
 660     if ( !bOk ) {
 661         wxLogError(_("Can't save log contents to file."));
 662     }
 663     else {
 664         wxLogStatus((wxFrame*)this, _("Log saved to the file '%s'."), filename.c_str());
 665     }
 666 }
 667 #endif // CAN_SAVE_FILES
 668
 669 void wxLogFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 670 {
 671     m_pTextCtrl->Clear();
 672 }
 673
 674 void wxLogFrame::OnInternalIdle()
 675 {
 676     {
 677         wxCRIT_SECT_LOCKER(locker, m_critSection);
 678
 679         const size_t count = m_pendingMessages.size();
 680         for ( size_t n = 0; n < count; n++ )
 681         {
 682             DoShowLogMessage(m_pendingMessages[n]);
 683         }
 684
 685         m_pendingMessages.clear();
 686     } // release m_critSection
 687
 688     wxFrame::OnInternalIdle();
 689 }
 690
 691 void wxLogFrame::AddLogMessage(const wxString& message)
 692 {
 693     wxCRIT_SECT_LOCKER(locker, m_critSection);
 694
 695 #if wxUSE_THREADS
 696     if ( !wxThread::IsMain() || !m_pendingMessages.empty() )
 697     {
 698         // message needs to be queued for later showing
 699         m_pendingMessages.Add(message);
 700
 701         wxWakeUpIdle();
 702     }
 703     else // we are the main thread and no messages are queued, so we can
 704          // log the message directly
 705 #endif // wxUSE_THREADS
 706     {
 707         DoShowLogMessage(message);
 708     }
 709 }
 710
 711 wxLogFrame::~wxLogFrame()
 712 {
 713     m_log->OnFrameDelete(this);
 714 }
 715
 716 // wxLogWindow
 717 // -----------
 718
 719 wxLogWindow::wxLogWindow(wxWindow *pParent,
 720                          const wxString& szTitle,
 721                          bool bShow,
 722                          bool bDoPass)
 723 {
 724     PassMessages(bDoPass);
 725
 726     m_pLogFrame = new wxLogFrame(pParent, this, szTitle);
 727
 728     if ( bShow )
 729         m_pLogFrame->Show();
 730 }
 731
 732 void wxLogWindow::Show(bool bShow)
 733 {
 734     m_pLogFrame->Show(bShow);
 735 }
 736
 737 void wxLogWindow::DoLog(wxLogLevel level, const wxString& szString, time_t t)
 738 {
 739     // first let the previous logger show it
 740     wxLogPassThrough::DoLog(level, szString, t);
 741
 742     if ( m_pLogFrame ) {
 743         switch ( level ) {
 744             case wxLOG_Status:
 745                 // by default, these messages are ignored by wxLog, so process
 746                 // them ourselves
 747                 if ( !szString.empty() )
 748                 {
 749                     wxString str;
 750                     str << _("Status: ") << szString;
 751                     LogString(str, t);
 752                 }
 753                 break;
 754
 755                 // don't put trace messages in the text window for 2 reasons:
 756                 // 1) there are too many of them
 757                 // 2) they may provoke other trace messages thus sending a program
 758                 //    into an infinite loop
 759             case wxLOG_Trace:
 760                 break;
 761
 762             default:
 763                 // and this will format it nicely and call our DoLogString()
 764                 wxLog::DoLog(level, szString, t);
 765         }
 766     }
 767 }
 768
 769 void wxLogWindow::DoLogString(const wxString& szString, time_t WXUNUSED(t))
 770 {
 771     wxString msg;
 772
 773     TimeStamp(&msg);
 774     msg << szString << wxT('\n');
 775
 776     m_pLogFrame->AddLogMessage(msg);
 777 }
 778
 779 wxFrame *wxLogWindow::GetFrame() const
 780 {
 781     return m_pLogFrame;
 782 }
 783
 784 void wxLogWindow::OnFrameCreate(wxFrame * WXUNUSED(frame))
 785 {
 786 }
 787
 788 bool wxLogWindow::OnFrameClose(wxFrame * WXUNUSED(frame))
 789 {
 790     // allow to close
 791     return true;
 792 }
 793
 794 void wxLogWindow::OnFrameDelete(wxFrame * WXUNUSED(frame))
 795 {
 796     m_pLogFrame = NULL;
 797 }
 798
 799 wxLogWindow::~wxLogWindow()
 800 {
 801     // may be NULL if log frame already auto destroyed itself
 802     delete m_pLogFrame;
 803 }
 804
 805 #endif // wxUSE_LOGWINDOW
 806
 807 // ----------------------------------------------------------------------------
 808 // wxLogDialog
 809 // ----------------------------------------------------------------------------
 810
 811 #if wxUSE_LOG_DIALOG
 812
 813 wxString wxLogDialog::ms_details;
 814 size_t wxLogDialog::ms_maxLength = 0;
 815
 816 wxLogDialog::wxLogDialog(wxWindow *parent,
 817                          const wxArrayString& messages,
 818                          const wxArrayInt& severity,
 819                          const wxArrayLong& times,
 820                          const wxString& caption,
 821                          long style)
 822            : wxDialog(parent, wxID_ANY, caption,
 823                       wxDefaultPosition, wxDefaultSize,
 824                       wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
 825 {
 826     // init the static variables:
 827
 828     if ( ms_details.empty() )
 829     {
 830         // ensure that we won't loop here if wxGetTranslation()
 831         // happens to pop up a Log message while translating this :-)
 832         ms_details = wxTRANSLATE("&Details");
 833         ms_details = wxGetTranslation(ms_details);
 834 #ifdef __SMARTPHONE__
 835         ms_details = wxStripMenuCodes(ms_details);
 836 #endif
 837     }
 838
 839     if ( ms_maxLength == 0 )
 840     {
 841         ms_maxLength = (2 * wxGetDisplaySize().x/3) / GetCharWidth();
 842     }
 843
 844     size_t count = messages.GetCount();
 845     m_messages.Alloc(count);
 846     m_severity.Alloc(count);
 847     m_times.Alloc(count);
 848
 849     for ( size_t n = 0; n < count; n++ )
 850     {
 851         m_messages.Add(messages[n]);
 852         m_severity.Add(severity[n]);
 853         m_times.Add(times[n]);
 854     }
 855
 856     m_listctrl = NULL;
 857
 858     bool isPda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
 859
 860     // create the controls which are always shown and layout them: we use
 861     // sizers even though our window is not resizeable to calculate the size of
 862     // the dialog properly
 863     wxBoxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
 864     wxBoxSizer *sizerAll = new wxBoxSizer(isPda ? wxVERTICAL : wxHORIZONTAL);
 865
 866     if (!isPda)
 867     {
 868         wxStaticBitmap *icon = new wxStaticBitmap
 869                                    (
 870                                     this,
 871                                     wxID_ANY,
 872                                     wxArtProvider::GetMessageBoxIcon(style)
 873                                    );
 874         sizerAll->Add(icon, wxSizerFlags().Centre());
 875     }
 876
 877     // create the text sizer with a minimal size so that we are sure it won't be too small
 878     wxString message = EllipsizeString(messages.Last());
 879     wxSizer *szText = CreateTextSizer(message);
 880     szText->SetMinSize(wxMin(300, wxGetDisplaySize().x / 3), -1);
 881
 882     sizerAll->Add(szText, wxSizerFlags(1).Centre().Border(wxLEFT | wxRIGHT));
 883
 884     wxButton *btnOk = new wxButton(this, wxID_OK);
 885     sizerAll->Add(btnOk, wxSizerFlags().Centre());
 886
 887     sizerTop->Add(sizerAll, wxSizerFlags().Expand().Border());
 888
 889
 890     // add the details pane
 891 #ifndef __SMARTPHONE__
 892     wxCollapsiblePane * const
 893         collpane = new wxCollapsiblePane(this, wxID_ANY, ms_details);
 894     sizerTop->Add(collpane, wxSizerFlags(1).Expand().Border());
 895
 896     wxWindow *win = collpane->GetPane();
 897     wxSizer * const paneSz = new wxBoxSizer(wxVERTICAL);
 898
 899     CreateDetailsControls(win);
 900
 901     paneSz->Add(m_listctrl, wxSizerFlags(1).Expand().Border(wxTOP));
 902
 903 #if wxUSE_CLIPBOARD || CAN_SAVE_FILES
 904     wxBoxSizer * const btnSizer = new wxBoxSizer(wxHORIZONTAL);
 905
 906     wxSizerFlags flagsBtn;
 907     flagsBtn.Border(wxLEFT);
 908
 909 #if wxUSE_CLIPBOARD
 910     btnSizer->Add(new wxButton(win, wxID_COPY), flagsBtn);
 911 #endif // wxUSE_CLIPBOARD
 912
 913 #if CAN_SAVE_FILES
 914     btnSizer->Add(new wxButton(win, wxID_SAVE), flagsBtn);
 915 #endif // CAN_SAVE_FILES
 916
 917     paneSz->Add(btnSizer, wxSizerFlags().Right().Border(wxTOP));
 918 #endif // wxUSE_CLIPBOARD || CAN_SAVE_FILES
 919
 920     win->SetSizer(paneSz);
 921     paneSz->SetSizeHints(win);
 922 #else // __SMARTPHONE__
 923     SetLeftMenu(wxID_OK);
 924     SetRightMenu(wxID_MORE, ms_details + EXPAND_SUFFIX);
 925 #endif // __SMARTPHONE__/!__SMARTPHONE__
 926
 927     SetSizerAndFit(sizerTop);
 928
 929     Centre();
 930
 931     if (isPda)
 932     {
 933         // Move up the screen so that when we expand the dialog,
 934         // there's enough space.
 935         Move(wxPoint(GetPosition().x, GetPosition().y / 2));
 936     }
 937 }
 938
 939 void wxLogDialog::CreateDetailsControls(wxWindow *parent)
 940 {
 941     // create the list ctrl now
 942     m_listctrl = new wxListCtrl(parent, wxID_ANY,
 943                                 wxDefaultPosition, wxDefaultSize,
 944                                 wxSUNKEN_BORDER |
 945                                 wxLC_REPORT |
 946                                 wxLC_NO_HEADER |
 947                                 wxLC_SINGLE_SEL);
 948 #ifdef __WXWINCE__
 949     // This makes a big aesthetic difference on WinCE but I
 950     // don't want to risk problems on other platforms
 951     m_listctrl->Hide();
 952 #endif
 953
 954     // no need to translate these strings as they're not shown to the
 955     // user anyhow (we use wxLC_NO_HEADER style)
 956     m_listctrl->InsertColumn(0, _T("Message"));
 957     m_listctrl->InsertColumn(1, _T("Time"));
 958
 959     // prepare the imagelist
 960     static const int ICON_SIZE = 16;
 961     wxImageList *imageList = new wxImageList(ICON_SIZE, ICON_SIZE);
 962
 963     // order should be the same as in the switch below!
 964     static const wxChar* icons[] =
 965     {
 966         wxART_ERROR,
 967         wxART_WARNING,
 968         wxART_INFORMATION
 969     };
 970
 971     bool loadedIcons = true;
 972
 973     for ( size_t icon = 0; icon < WXSIZEOF(icons); icon++ )
 974     {
 975         wxBitmap bmp = wxArtProvider::GetBitmap(icons[icon], wxART_MESSAGE_BOX,
 976                                                 wxSize(ICON_SIZE, ICON_SIZE));
 977
 978         // This may very well fail if there are insufficient colours available.
 979         // Degrade gracefully.
 980         if ( !bmp.Ok() )
 981         {
 982             loadedIcons = false;
 983
 984             break;
 985         }
 986
 987         imageList->Add(bmp);
 988     }
 989
 990     m_listctrl->SetImageList(imageList, wxIMAGE_LIST_SMALL);
 991
 992     // and fill it
 993     wxString fmt = wxLog::GetTimestamp();
 994     if ( !fmt )
 995     {
 996         // default format
 997         fmt = _T("%c");
 998     }
 999
1000     size_t count = m_messages.GetCount();
1001     for ( size_t n = 0; n < count; n++ )
1002     {
1003         int image;
1004
1005         if ( loadedIcons )
1006         {
1007             switch ( m_severity[n] )
1008             {
1009                 case wxLOG_Error:
1010                     image = 0;
1011                     break;
1012
1013                 case wxLOG_Warning:
1014                     image = 1;
1015                     break;
1016
1017                 default:
1018                     image = 2;
1019             }
1020         }
1021         else // failed to load images
1022         {
1023             image = -1;
1024         }
1025
1026         wxString msg = m_messages[n];
1027         msg.Replace(wxT("\n"), wxT(" "));
1028         msg = EllipsizeString(msg);
1029
1030         m_listctrl->InsertItem(n, msg, image);
1031         m_listctrl->SetItem(n, 1, TimeStamp(fmt, (time_t)m_times[n]));
1032     }
1033
1034     // let the columns size themselves
1035     m_listctrl->SetColumnWidth(0, wxLIST_AUTOSIZE);
1036     m_listctrl->SetColumnWidth(1, wxLIST_AUTOSIZE);
1037
1038     // calculate an approximately nice height for the listctrl
1039     int height = GetCharHeight()*(count + 4);
1040
1041     // but check that the dialog won't fall fown from the screen
1042     //
1043     // we use GetMinHeight() to get the height of the dialog part without the
1044     // details and we consider that the "Save" button below and the separator
1045     // line (and the margins around it) take about as much, hence double it
1046     int heightMax = wxGetDisplaySize().y - GetPosition().y - 2*GetMinHeight();
1047
1048     // we should leave a margin
1049     heightMax *= 9;
1050     heightMax /= 10;
1051
1052     m_listctrl->SetSize(wxDefaultCoord, wxMin(height, heightMax));
1053 }
1054
1055 void wxLogDialog::OnListSelect(wxListEvent& event)
1056 {
1057     // we can't just disable the control because this looks ugly under Windows
1058     // (wrong bg colour, no scrolling...), but we still want to disable
1059     // selecting items - it makes no sense here
1060     m_listctrl->SetItemState(event.GetIndex(), 0, wxLIST_STATE_SELECTED);
1061 }
1062
1063 void wxLogDialog::OnListItemActivated(wxListEvent& event)
1064 {
1065     // show the activated item in a message box
1066     // This allow the user to correctly display the logs which are longer
1067     // than the listctrl and thus gets truncated or those which contains
1068     // newlines.
1069
1070     // NB: don't do:
1071     //    wxString str = m_listctrl->GetItemText(event.GetIndex());
1072     // as there's a 260 chars limit on the items inside a wxListCtrl in wxMSW.
1073     wxString str = m_messages[event.GetIndex()];
1074
1075     // wxMessageBox will nicely handle the '\n' in the string (if any)
1076     // and supports long strings
1077     wxMessageBox(str, wxT("Log message"), wxOK, this);
1078 }
1079
1080 void wxLogDialog::OnOk(wxCommandEvent& WXUNUSED(event))
1081 {
1082     EndModal(wxID_OK);
1083 }
1084
1085 #if CAN_SAVE_FILES || wxUSE_CLIPBOARD
1086
1087 wxString wxLogDialog::GetLogMessages() const
1088 {
1089     wxString fmt = wxLog::GetTimestamp();
1090     if ( fmt.empty() )
1091     {
1092         // use the default format
1093         fmt = "%c";
1094     }
1095
1096     const size_t count = m_messages.GetCount();
1097
1098     wxString text;
1099     text.reserve(count*m_messages[0].length());
1100     for ( size_t n = 0; n < count; n++ )
1101     {
1102         text << TimeStamp(fmt, (time_t)m_times[n])
1103              << ": "
1104              << m_messages[n]
1105              << wxTextFile::GetEOL();
1106     }
1107
1108     return text;
1109 }
1110
1111 #endif // CAN_SAVE_FILES || wxUSE_CLIPBOARD
1112
1113 #if wxUSE_CLIPBOARD
1114
1115 void wxLogDialog::OnCopy(wxCommandEvent& WXUNUSED(event))
1116 {
1117     wxClipboardLocker clip;
1118     if ( !clip ||
1119             !wxTheClipboard->AddData(new wxTextDataObject(GetLogMessages())) )
1120     {
1121         wxLogError(_("Failed to copy dialog contents to the clipboard."));
1122     }
1123 }
1124
1125 #endif // wxUSE_CLIPBOARD
1126
1127 #if CAN_SAVE_FILES
1128
1129 void wxLogDialog::OnSave(wxCommandEvent& WXUNUSED(event))
1130 {
1131     wxFile file;
1132     int rc = OpenLogFile(file, NULL, this);
1133     if ( rc == -1 )
1134     {
1135         // cancelled
1136         return;
1137     }
1138
1139     if ( !rc || !file.Write(GetLogMessages()) || !file.Close() )
1140         wxLogError(_("Can't save log contents to file."));
1141 }
1142
1143 #endif // CAN_SAVE_FILES
1144
1145 wxLogDialog::~wxLogDialog()
1146 {
1147     if ( m_listctrl )
1148     {
1149         delete m_listctrl->GetImageList(wxIMAGE_LIST_SMALL);
1150     }
1151 }
1152
1153 #endif // wxUSE_LOG_DIALOG
1154
1155 #if CAN_SAVE_FILES
1156
1157 // pass an uninitialized file object, the function will ask the user for the
1158 // filename and try to open it, returns true on success (file was opened),
1159 // false if file couldn't be opened/created and -1 if the file selection
1160 // dialog was cancelled
1161 static int OpenLogFile(wxFile& file, wxString *pFilename, wxWindow *parent)
1162 {
1163     // get the file name
1164     // -----------------
1165     wxString filename = wxSaveFileSelector(wxT("log"), wxT("txt"), wxT("log.txt"), parent);
1166     if ( !filename ) {
1167         // cancelled
1168         return -1;
1169     }
1170
1171     // open file
1172     // ---------
1173     bool bOk;
1174     if ( wxFile::Exists(filename) ) {
1175         bool bAppend = false;
1176         wxString strMsg;
1177         strMsg.Printf(_("Append log to file '%s' (choosing [No] will overwrite it)?"),
1178                       filename.c_str());
1179         switch ( wxMessageBox(strMsg, _("Question"),
1180                               wxICON_QUESTION | wxYES_NO | wxCANCEL) ) {
1181             case wxYES:
1182                 bAppend = true;
1183                 break;
1184
1185             case wxNO:
1186                 bAppend = false;
1187                 break;
1188
1189             case wxCANCEL:
1190                 return -1;
1191
1192             default:
1193                 wxFAIL_MSG(_("invalid message box return value"));
1194         }
1195
1196         if ( bAppend ) {
1197             bOk = file.Open(filename, wxFile::write_append);
1198         }
1199         else {
1200             bOk = file.Create(filename, true /* overwrite */);
1201         }
1202     }
1203     else {
1204         bOk = file.Create(filename);
1205     }
1206
1207     if ( pFilename )
1208         *pFilename = filename;
1209
1210     return bOk;
1211 }
1212
1213 #endif // CAN_SAVE_FILES
1214
1215 #endif // !(wxUSE_LOGGUI || wxUSE_LOGWINDOW)
1216
1217 #if wxUSE_LOG && wxUSE_TEXTCTRL
1218
1219 // ----------------------------------------------------------------------------
1220 // wxLogTextCtrl implementation
1221 // ----------------------------------------------------------------------------
1222
1223 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl *pTextCtrl)
1224 {
1225     m_pTextCtrl = pTextCtrl;
1226 }
1227
1228 void wxLogTextCtrl::DoLogString(const wxString& szString, time_t WXUNUSED(t))
1229 {
1230     wxString msg;
1231     TimeStamp(&msg);
1232
1233     msg << szString << wxT('\n');
1234     m_pTextCtrl->AppendText(msg);
1235 }
1236
1237 #endif // wxUSE_LOG && wxUSE_TEXTCTRL