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     const size_t nMsgCount = messages.size();
 344     message.reserve(nMsgCount*100);
 345     for ( size_t n = nMsgCount; n > 0; n-- ) {
 346         message << m_aMessages[n - 1] << wxT("\n");
 347     }
 348
 349     DoShowSingleLogMessage(message, title, style);
 350 #endif // wxUSE_LOG_DIALOG/!wxUSE_LOG_DIALOG
 351 }
 352
 353 void wxLogGui::Flush()
 354 {
 355     if ( !m_bHasMessages )
 356         return;
 357
 358     // do it right now to block any new calls to Flush() while we're here
 359     m_bHasMessages = false;
 360
 361     // note that this must be done before examining m_aMessages as it may log
 362     // yet another message
 363     const unsigned repeatCount = LogLastRepeatIfNeeded();
 364
 365     const size_t nMsgCount = m_aMessages.size();
 366
 367     if ( repeatCount > 0 )
 368     {
 369         m_aMessages[nMsgCount - 1] << " (" << m_aMessages[nMsgCount - 2] << ")";
 370     }
 371
 372     const wxString title = GetTitle();
 373     const int style = GetSeverityIcon();
 374
 375     // avoid showing other log dialogs until we're done with the dialog we're
 376     // showing right now: nested modal dialogs make for really bad UI!
 377     Suspend();
 378
 379     if ( nMsgCount == 1 )
 380     {
 381         // make a copy before calling Clear()
 382         const wxString message(m_aMessages[0]);
 383         Clear();
 384
 385         DoShowSingleLogMessage(message, title, style);
 386     }
 387     else // more than one message
 388     {
 389         wxArrayString messages;
 390         wxArrayInt severities;
 391         wxArrayLong times;
 392
 393         messages.swap(m_aMessages);
 394         severities.swap(m_aSeverity);
 395         times.swap(m_aTimes);
 396
 397         Clear();
 398
 399         DoShowMultipleLogMessages(messages, severities, times, title, style);
 400     }
 401
 402     // allow flushing the logs again
 403     Resume();
 404 }
 405
 406 // log all kinds of messages
 407 void wxLogGui::DoLog(wxLogLevel level, const wxString& szString, time_t t)
 408 {
 409     switch ( level ) {
 410         case wxLOG_Info:
 411             if ( GetVerbose() )
 412         case wxLOG_Message:
 413             {
 414                 m_aMessages.Add(szString);
 415                 m_aSeverity.Add(wxLOG_Message);
 416                 m_aTimes.Add((long)t);
 417                 m_bHasMessages = true;
 418             }
 419             break;
 420
 421         case wxLOG_Status:
 422 #if wxUSE_STATUSBAR
 423             {
 424                 // find the top window and set it's status text if it has any
 425                 wxFrame *pFrame = gs_pFrame;
 426                 if ( pFrame == NULL ) {
 427                     wxWindow *pWin = wxTheApp->GetTopWindow();
 428                     if ( pWin != NULL && pWin->IsKindOf(CLASSINFO(wxFrame)) ) {
 429                         pFrame = (wxFrame *)pWin;
 430                     }
 431                 }
 432
 433                 if ( pFrame && pFrame->GetStatusBar() )
 434                     pFrame->SetStatusText(szString);
 435             }
 436 #endif // wxUSE_STATUSBAR
 437             break;
 438
 439         case wxLOG_Trace:
 440         case wxLOG_Debug:
 441             #ifdef __WXDEBUG__
 442             {
 443                 wxString str;
 444                 TimeStamp(&str);
 445                 str += szString;
 446
 447                 #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
 448                     // don't prepend debug/trace here: it goes to the
 449                     // debug window anyhow
 450                     str += wxT("\r\n");
 451                     OutputDebugString(str.wx_str());
 452                 #else
 453                     // send them to stderr
 454                     wxFprintf(stderr, wxT("[%s] %s\n"),
 455                               level == wxLOG_Trace ? wxT("Trace")
 456                                                    : wxT("Debug"),
 457                               str.c_str());
 458                     fflush(stderr);
 459                 #endif
 460             }
 461             #endif // __WXDEBUG__
 462
 463             break;
 464
 465         case wxLOG_FatalError:
 466             // show this one immediately
 467             wxMessageBox(szString, _("Fatal error"), wxICON_HAND);
 468             wxExit();
 469             break;
 470
 471         case wxLOG_Error:
 472             if ( !m_bErrors ) {
 473 #if !wxUSE_LOG_DIALOG
 474                 // discard earlier informational messages if this is the 1st
 475                 // error because they might not make sense any more and showing
 476                 // them in a message box might be confusing
 477                 m_aMessages.Empty();
 478                 m_aSeverity.Empty();
 479                 m_aTimes.Empty();
 480 #endif // wxUSE_LOG_DIALOG
 481                 m_bErrors = true;
 482             }
 483             // fall through
 484
 485         case wxLOG_Warning:
 486             if ( !m_bErrors ) {
 487                 // for the warning we don't discard the info messages
 488                 m_bWarnings = true;
 489             }
 490
 491             m_aMessages.Add(szString);
 492             m_aSeverity.Add((int)level);
 493             m_aTimes.Add((long)t);
 494             m_bHasMessages = true;
 495             break;
 496     }
 497 }
 498
 499 #endif   // wxUSE_LOGGUI
 500
 501 // ----------------------------------------------------------------------------
 502 // wxLogWindow and wxLogFrame implementation
 503 // ----------------------------------------------------------------------------
 504
 505 #if wxUSE_LOGWINDOW
 506
 507 // log frame class
 508 // ---------------
 509 class wxLogFrame : public wxFrame
 510 {
 511 public:
 512     // ctor & dtor
 513     wxLogFrame(wxWindow *pParent, wxLogWindow *log, const wxString& szTitle);
 514     virtual ~wxLogFrame();
 515
 516     // menu callbacks
 517     void OnClose(wxCommandEvent& event);
 518     void OnCloseWindow(wxCloseEvent& event);
 519 #if CAN_SAVE_FILES
 520     void OnSave(wxCommandEvent& event);
 521 #endif // CAN_SAVE_FILES
 522     void OnClear(wxCommandEvent& event);
 523
 524     // this function is safe to call from any thread (notice that it should be
 525     // also called from the main thread to ensure that the messages logged from
 526     // it appear in correct order with the messages from the other threads)
 527     void AddLogMessage(const wxString& message);
 528
 529     // actually append the messages logged from secondary threads to the text
 530     // control during idle time in the main thread
 531     virtual void OnInternalIdle();
 532
 533 private:
 534     // use standard ids for our commands!
 535     enum
 536     {
 537         Menu_Close = wxID_CLOSE,
 538         Menu_Save  = wxID_SAVE,
 539         Menu_Clear = wxID_CLEAR
 540     };
 541
 542     // common part of OnClose() and OnCloseWindow()
 543     void DoClose();
 544
 545     // do show the message in the text control
 546     void DoShowLogMessage(const wxString& message)
 547     {
 548         m_pTextCtrl->AppendText(message);
 549     }
 550
 551     wxTextCtrl  *m_pTextCtrl;
 552     wxLogWindow *m_log;
 553
 554     // queue of messages logged from other threads which need to be displayed
 555     wxArrayString m_pendingMessages;
 556
 557 #if wxUSE_THREADS
 558     // critical section to protect access to m_pendingMessages
 559     wxCriticalSection m_critSection;
 560 #endif // wxUSE_THREADS
 561
 562
 563     DECLARE_EVENT_TABLE()
 564     DECLARE_NO_COPY_CLASS(wxLogFrame)
 565 };
 566
 567 BEGIN_EVENT_TABLE(wxLogFrame, wxFrame)
 568     // wxLogWindow menu events
 569     EVT_MENU(Menu_Close, wxLogFrame::OnClose)
 570 #if CAN_SAVE_FILES
 571     EVT_MENU(Menu_Save,  wxLogFrame::OnSave)
 572 #endif // CAN_SAVE_FILES
 573     EVT_MENU(Menu_Clear, wxLogFrame::OnClear)
 574
 575     EVT_CLOSE(wxLogFrame::OnCloseWindow)
 576 END_EVENT_TABLE()
 577
 578 wxLogFrame::wxLogFrame(wxWindow *pParent, wxLogWindow *log, const wxString& szTitle)
 579           : wxFrame(pParent, wxID_ANY, szTitle)
 580 {
 581     m_log = log;
 582
 583     m_pTextCtrl = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition,
 584             wxDefaultSize,
 585             wxTE_MULTILINE  |
 586             wxHSCROLL       |
 587             // needed for Win32 to avoid 65Kb limit but it doesn't work well
 588             // when using RichEdit 2.0 which we always do in the Unicode build
 589 #if !wxUSE_UNICODE
 590             wxTE_RICH       |
 591 #endif // !wxUSE_UNICODE
 592             wxTE_READONLY);
 593
 594 #if wxUSE_MENUS
 595     // create menu
 596     wxMenuBar *pMenuBar = new wxMenuBar;
 597     wxMenu *pMenu = new wxMenu;
 598 #if CAN_SAVE_FILES
 599     pMenu->Append(Menu_Save,  _("&Save..."), _("Save log contents to file"));
 600 #endif // CAN_SAVE_FILES
 601     pMenu->Append(Menu_Clear, _("C&lear"), _("Clear the log contents"));
 602     pMenu->AppendSeparator();
 603     pMenu->Append(Menu_Close, _("&Close"), _("Close this window"));
 604     pMenuBar->Append(pMenu, _("&Log"));
 605     SetMenuBar(pMenuBar);
 606 #endif // wxUSE_MENUS
 607
 608 #if wxUSE_STATUSBAR
 609     // status bar for menu prompts
 610     CreateStatusBar();
 611 #endif // wxUSE_STATUSBAR
 612
 613     m_log->OnFrameCreate(this);
 614 }
 615
 616 void wxLogFrame::DoClose()
 617 {
 618     if ( m_log->OnFrameClose(this) )
 619     {
 620         // instead of closing just hide the window to be able to Show() it
 621         // later
 622         Show(false);
 623     }
 624 }
 625
 626 void wxLogFrame::OnClose(wxCommandEvent& WXUNUSED(event))
 627 {
 628     DoClose();
 629 }
 630
 631 void wxLogFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 632 {
 633     DoClose();
 634 }
 635
 636 #if CAN_SAVE_FILES
 637 void wxLogFrame::OnSave(wxCommandEvent& WXUNUSED(event))
 638 {
 639     wxString filename;
 640     wxFile file;
 641     int rc = OpenLogFile(file, &filename, this);
 642     if ( rc == -1 )
 643     {
 644         // cancelled
 645         return;
 646     }
 647
 648     bool bOk = rc != 0;
 649
 650     // retrieve text and save it
 651     // -------------------------
 652     int nLines = m_pTextCtrl->GetNumberOfLines();
 653     for ( int nLine = 0; bOk && nLine < nLines; nLine++ ) {
 654         bOk = file.Write(m_pTextCtrl->GetLineText(nLine) +
 655                          wxTextFile::GetEOL());
 656     }
 657
 658     if ( bOk )
 659         bOk = file.Close();
 660
 661     if ( !bOk ) {
 662         wxLogError(_("Can't save log contents to file."));
 663     }
 664     else {
 665         wxLogStatus((wxFrame*)this, _("Log saved to the file '%s'."), filename.c_str());
 666     }
 667 }
 668 #endif // CAN_SAVE_FILES
 669
 670 void wxLogFrame::OnClear(wxCommandEvent& WXUNUSED(event))
 671 {
 672     m_pTextCtrl->Clear();
 673 }
 674
 675 void wxLogFrame::OnInternalIdle()
 676 {
 677     {
 678         wxCRIT_SECT_LOCKER(locker, m_critSection);
 679
 680         const size_t count = m_pendingMessages.size();
 681         for ( size_t n = 0; n < count; n++ )
 682         {
 683             DoShowLogMessage(m_pendingMessages[n]);
 684         }
 685
 686         m_pendingMessages.clear();
 687     } // release m_critSection
 688
 689     wxFrame::OnInternalIdle();
 690 }
 691
 692 void wxLogFrame::AddLogMessage(const wxString& message)
 693 {
 694     wxCRIT_SECT_LOCKER(locker, m_critSection);
 695
 696 #if wxUSE_THREADS
 697     if ( !wxThread::IsMain() || !m_pendingMessages.empty() )
 698     {
 699         // message needs to be queued for later showing
 700         m_pendingMessages.Add(message);
 701
 702         wxWakeUpIdle();
 703     }
 704     else // we are the main thread and no messages are queued, so we can
 705          // log the message directly
 706 #endif // wxUSE_THREADS
 707     {
 708         DoShowLogMessage(message);
 709     }
 710 }
 711
 712 wxLogFrame::~wxLogFrame()
 713 {
 714     m_log->OnFrameDelete(this);
 715 }
 716
 717 // wxLogWindow
 718 // -----------
 719
 720 wxLogWindow::wxLogWindow(wxWindow *pParent,
 721                          const wxString& szTitle,
 722                          bool bShow,
 723                          bool bDoPass)
 724 {
 725     PassMessages(bDoPass);
 726
 727     m_pLogFrame = new wxLogFrame(pParent, this, szTitle);
 728
 729     if ( bShow )
 730         m_pLogFrame->Show();
 731 }
 732
 733 void wxLogWindow::Show(bool bShow)
 734 {
 735     m_pLogFrame->Show(bShow);
 736 }
 737
 738 void wxLogWindow::DoLog(wxLogLevel level, const wxString& szString, time_t t)
 739 {
 740     // first let the previous logger show it
 741     wxLogPassThrough::DoLog(level, szString, t);
 742
 743     if ( m_pLogFrame ) {
 744         switch ( level ) {
 745             case wxLOG_Status:
 746                 // by default, these messages are ignored by wxLog, so process
 747                 // them ourselves
 748                 if ( !szString.empty() )
 749                 {
 750                     wxString str;
 751                     str << _("Status: ") << szString;
 752                     LogString(str, t);
 753                 }
 754                 break;
 755
 756                 // don't put trace messages in the text window for 2 reasons:
 757                 // 1) there are too many of them
 758                 // 2) they may provoke other trace messages thus sending a program
 759                 //    into an infinite loop
 760             case wxLOG_Trace:
 761                 break;
 762
 763             default:
 764                 // and this will format it nicely and call our DoLogString()
 765                 wxLog::DoLog(level, szString, t);
 766         }
 767     }
 768 }
 769
 770 void wxLogWindow::DoLogString(const wxString& szString, time_t WXUNUSED(t))
 771 {
 772     wxString msg;
 773
 774     TimeStamp(&msg);
 775     msg << szString << wxT('\n');
 776
 777     m_pLogFrame->AddLogMessage(msg);
 778 }
 779
 780 wxFrame *wxLogWindow::GetFrame() const
 781 {
 782     return m_pLogFrame;
 783 }
 784
 785 void wxLogWindow::OnFrameCreate(wxFrame * WXUNUSED(frame))
 786 {
 787 }
 788
 789 bool wxLogWindow::OnFrameClose(wxFrame * WXUNUSED(frame))
 790 {
 791     // allow to close
 792     return true;
 793 }
 794
 795 void wxLogWindow::OnFrameDelete(wxFrame * WXUNUSED(frame))
 796 {
 797     m_pLogFrame = NULL;
 798 }
 799
 800 wxLogWindow::~wxLogWindow()
 801 {
 802     // may be NULL if log frame already auto destroyed itself
 803     delete m_pLogFrame;
 804 }
 805
 806 #endif // wxUSE_LOGWINDOW
 807
 808 // ----------------------------------------------------------------------------
 809 // wxLogDialog
 810 // ----------------------------------------------------------------------------
 811
 812 #if wxUSE_LOG_DIALOG
 813
 814 wxString wxLogDialog::ms_details;
 815 size_t wxLogDialog::ms_maxLength = 0;
 816
 817 wxLogDialog::wxLogDialog(wxWindow *parent,
 818                          const wxArrayString& messages,
 819                          const wxArrayInt& severity,
 820                          const wxArrayLong& times,
 821                          const wxString& caption,
 822                          long style)
 823            : wxDialog(parent, wxID_ANY, caption,
 824                       wxDefaultPosition, wxDefaultSize,
 825                       wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
 826 {
 827     // init the static variables:
 828
 829     if ( ms_details.empty() )
 830     {
 831         // ensure that we won't loop here if wxGetTranslation()
 832         // happens to pop up a Log message while translating this :-)
 833         ms_details = wxTRANSLATE("&Details");
 834         ms_details = wxGetTranslation(ms_details);
 835 #ifdef __SMARTPHONE__
 836         ms_details = wxStripMenuCodes(ms_details);
 837 #endif
 838     }
 839
 840     if ( ms_maxLength == 0 )
 841     {
 842         ms_maxLength = (2 * wxGetDisplaySize().x/3) / GetCharWidth();
 843     }
 844
 845     size_t count = messages.GetCount();
 846     m_messages.Alloc(count);
 847     m_severity.Alloc(count);
 848     m_times.Alloc(count);
 849
 850     for ( size_t n = 0; n < count; n++ )
 851     {
 852         m_messages.Add(messages[n]);
 853         m_severity.Add(severity[n]);
 854         m_times.Add(times[n]);
 855     }
 856
 857     m_listctrl = NULL;
 858
 859     bool isPda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
 860
 861     // create the controls which are always shown and layout them: we use
 862     // sizers even though our window is not resizeable to calculate the size of
 863     // the dialog properly
 864     wxBoxSizer *sizerTop = new wxBoxSizer(wxVERTICAL);
 865     wxBoxSizer *sizerAll = new wxBoxSizer(isPda ? wxVERTICAL : wxHORIZONTAL);
 866
 867     if (!isPda)
 868     {
 869         wxStaticBitmap *icon = new wxStaticBitmap
 870                                    (
 871                                     this,
 872                                     wxID_ANY,
 873                                     wxArtProvider::GetMessageBoxIcon(style)
 874                                    );
 875         sizerAll->Add(icon, wxSizerFlags().Centre());
 876     }
 877
 878     // create the text sizer with a minimal size so that we are sure it won't be too small
 879     wxString message = EllipsizeString(messages.Last());
 880     wxSizer *szText = CreateTextSizer(message);
 881     szText->SetMinSize(wxMin(300, wxGetDisplaySize().x / 3), -1);
 882
 883     sizerAll->Add(szText, wxSizerFlags(1).Centre().Border(wxLEFT | wxRIGHT));
 884
 885     wxButton *btnOk = new wxButton(this, wxID_OK);
 886     sizerAll->Add(btnOk, wxSizerFlags().Centre());
 887
 888     sizerTop->Add(sizerAll, wxSizerFlags().Expand().Border());
 889
 890
 891     // add the details pane
 892 #ifndef __SMARTPHONE__
 893     wxCollapsiblePane * const
 894         collpane = new wxCollapsiblePane(this, wxID_ANY, ms_details);
 895     sizerTop->Add(collpane, wxSizerFlags(1).Expand().Border());
 896
 897     wxWindow *win = collpane->GetPane();
 898     wxSizer * const paneSz = new wxBoxSizer(wxVERTICAL);
 899
 900     CreateDetailsControls(win);
 901
 902     paneSz->Add(m_listctrl, wxSizerFlags(1).Expand().Border(wxTOP));
 903
 904 #if wxUSE_CLIPBOARD || CAN_SAVE_FILES
 905     wxBoxSizer * const btnSizer = new wxBoxSizer(wxHORIZONTAL);
 906
 907     wxSizerFlags flagsBtn;
 908     flagsBtn.Border(wxLEFT);
 909
 910 #if wxUSE_CLIPBOARD
 911     btnSizer->Add(new wxButton(win, wxID_COPY), flagsBtn);
 912 #endif // wxUSE_CLIPBOARD
 913
 914 #if CAN_SAVE_FILES
 915     btnSizer->Add(new wxButton(win, wxID_SAVE), flagsBtn);
 916 #endif // CAN_SAVE_FILES
 917
 918     paneSz->Add(btnSizer, wxSizerFlags().Right().Border(wxTOP));
 919 #endif // wxUSE_CLIPBOARD || CAN_SAVE_FILES
 920
 921     win->SetSizer(paneSz);
 922     paneSz->SetSizeHints(win);
 923 #else // __SMARTPHONE__
 924     SetLeftMenu(wxID_OK);
 925     SetRightMenu(wxID_MORE, ms_details + EXPAND_SUFFIX);
 926 #endif // __SMARTPHONE__/!__SMARTPHONE__
 927
 928     SetSizerAndFit(sizerTop);
 929
 930     Centre();
 931
 932     if (isPda)
 933     {
 934         // Move up the screen so that when we expand the dialog,
 935         // there's enough space.
 936         Move(wxPoint(GetPosition().x, GetPosition().y / 2));
 937     }
 938 }
 939
 940 void wxLogDialog::CreateDetailsControls(wxWindow *parent)
 941 {
 942     // create the list ctrl now
 943     m_listctrl = new wxListCtrl(parent, wxID_ANY,
 944                                 wxDefaultPosition, wxDefaultSize,
 945                                 wxSUNKEN_BORDER |
 946                                 wxLC_REPORT |
 947                                 wxLC_NO_HEADER |
 948                                 wxLC_SINGLE_SEL);
 949 #ifdef __WXWINCE__
 950     // This makes a big aesthetic difference on WinCE but I
 951     // don't want to risk problems on other platforms
 952     m_listctrl->Hide();
 953 #endif
 954
 955     // no need to translate these strings as they're not shown to the
 956     // user anyhow (we use wxLC_NO_HEADER style)
 957     m_listctrl->InsertColumn(0, _T("Message"));
 958     m_listctrl->InsertColumn(1, _T("Time"));
 959
 960     // prepare the imagelist
 961     static const int ICON_SIZE = 16;
 962     wxImageList *imageList = new wxImageList(ICON_SIZE, ICON_SIZE);
 963
 964     // order should be the same as in the switch below!
 965     static const wxChar* icons[] =
 966     {
 967         wxART_ERROR,
 968         wxART_WARNING,
 969         wxART_INFORMATION
 970     };
 971
 972     bool loadedIcons = true;
 973
 974     for ( size_t icon = 0; icon < WXSIZEOF(icons); icon++ )
 975     {
 976         wxBitmap bmp = wxArtProvider::GetBitmap(icons[icon], wxART_MESSAGE_BOX,
 977                                                 wxSize(ICON_SIZE, ICON_SIZE));
 978
 979         // This may very well fail if there are insufficient colours available.
 980         // Degrade gracefully.
 981         if ( !bmp.Ok() )
 982         {
 983             loadedIcons = false;
 984
 985             break;
 986         }
 987
 988         imageList->Add(bmp);
 989     }
 990
 991     m_listctrl->SetImageList(imageList, wxIMAGE_LIST_SMALL);
 992
 993     // and fill it
 994     wxString fmt = wxLog::GetTimestamp();
 995     if ( !fmt )
 996     {
 997         // default format
 998         fmt = _T("%c");
 999     }
1000
1001     size_t count = m_messages.GetCount();
1002     for ( size_t n = 0; n < count; n++ )
1003     {
1004         int image;
1005
1006         if ( loadedIcons )
1007         {
1008             switch ( m_severity[n] )
1009             {
1010                 case wxLOG_Error:
1011                     image = 0;
1012                     break;
1013
1014                 case wxLOG_Warning:
1015                     image = 1;
1016                     break;
1017
1018                 default:
1019                     image = 2;
1020             }
1021         }
1022         else // failed to load images
1023         {
1024             image = -1;
1025         }
1026
1027         wxString msg = m_messages[n];
1028         msg.Replace(wxT("\n"), wxT(" "));
1029         msg = EllipsizeString(msg);
1030
1031         m_listctrl->InsertItem(n, msg, image);
1032         m_listctrl->SetItem(n, 1, TimeStamp(fmt, (time_t)m_times[n]));
1033     }
1034
1035     // let the columns size themselves
1036     m_listctrl->SetColumnWidth(0, wxLIST_AUTOSIZE);
1037     m_listctrl->SetColumnWidth(1, wxLIST_AUTOSIZE);
1038
1039     // calculate an approximately nice height for the listctrl
1040     int height = GetCharHeight()*(count + 4);
1041
1042     // but check that the dialog won't fall fown from the screen
1043     //
1044     // we use GetMinHeight() to get the height of the dialog part without the
1045     // details and we consider that the "Save" button below and the separator
1046     // line (and the margins around it) take about as much, hence double it
1047     int heightMax = wxGetDisplaySize().y - GetPosition().y - 2*GetMinHeight();
1048
1049     // we should leave a margin
1050     heightMax *= 9;
1051     heightMax /= 10;
1052
1053     m_listctrl->SetSize(wxDefaultCoord, wxMin(height, heightMax));
1054 }
1055
1056 void wxLogDialog::OnListSelect(wxListEvent& event)
1057 {
1058     // we can't just disable the control because this looks ugly under Windows
1059     // (wrong bg colour, no scrolling...), but we still want to disable
1060     // selecting items - it makes no sense here
1061     m_listctrl->SetItemState(event.GetIndex(), 0, wxLIST_STATE_SELECTED);
1062 }
1063
1064 void wxLogDialog::OnListItemActivated(wxListEvent& event)
1065 {
1066     // show the activated item in a message box
1067     // This allow the user to correctly display the logs which are longer
1068     // than the listctrl and thus gets truncated or those which contains
1069     // newlines.
1070
1071     // NB: don't do:
1072     //    wxString str = m_listctrl->GetItemText(event.GetIndex());
1073     // as there's a 260 chars limit on the items inside a wxListCtrl in wxMSW.
1074     wxString str = m_messages[event.GetIndex()];
1075
1076     // wxMessageBox will nicely handle the '\n' in the string (if any)
1077     // and supports long strings
1078     wxMessageBox(str, wxT("Log message"), wxOK, this);
1079 }
1080
1081 void wxLogDialog::OnOk(wxCommandEvent& WXUNUSED(event))
1082 {
1083     EndModal(wxID_OK);
1084 }
1085
1086 #if CAN_SAVE_FILES || wxUSE_CLIPBOARD
1087
1088 wxString wxLogDialog::GetLogMessages() const
1089 {
1090     wxString fmt = wxLog::GetTimestamp();
1091     if ( fmt.empty() )
1092     {
1093         // use the default format
1094         fmt = "%c";
1095     }
1096
1097     const size_t count = m_messages.GetCount();
1098
1099     wxString text;
1100     text.reserve(count*m_messages[0].length());
1101     for ( size_t n = 0; n < count; n++ )
1102     {
1103         text << TimeStamp(fmt, (time_t)m_times[n])
1104              << ": "
1105              << m_messages[n]
1106              << wxTextFile::GetEOL();
1107     }
1108
1109     return text;
1110 }
1111
1112 #endif // CAN_SAVE_FILES || wxUSE_CLIPBOARD
1113
1114 #if wxUSE_CLIPBOARD
1115
1116 void wxLogDialog::OnCopy(wxCommandEvent& WXUNUSED(event))
1117 {
1118     wxClipboardLocker clip;
1119     if ( !clip ||
1120             !wxTheClipboard->AddData(new wxTextDataObject(GetLogMessages())) )
1121     {
1122         wxLogError(_("Failed to copy dialog contents to the clipboard."));
1123     }
1124 }
1125
1126 #endif // wxUSE_CLIPBOARD
1127
1128 #if CAN_SAVE_FILES
1129
1130 void wxLogDialog::OnSave(wxCommandEvent& WXUNUSED(event))
1131 {
1132     wxFile file;
1133     int rc = OpenLogFile(file, NULL, this);
1134     if ( rc == -1 )
1135     {
1136         // cancelled
1137         return;
1138     }
1139
1140     if ( !rc || !file.Write(GetLogMessages()) || !file.Close() )
1141         wxLogError(_("Can't save log contents to file."));
1142 }
1143
1144 #endif // CAN_SAVE_FILES
1145
1146 wxLogDialog::~wxLogDialog()
1147 {
1148     if ( m_listctrl )
1149     {
1150         delete m_listctrl->GetImageList(wxIMAGE_LIST_SMALL);
1151     }
1152 }
1153
1154 #endif // wxUSE_LOG_DIALOG
1155
1156 #if CAN_SAVE_FILES
1157
1158 // pass an uninitialized file object, the function will ask the user for the
1159 // filename and try to open it, returns true on success (file was opened),
1160 // false if file couldn't be opened/created and -1 if the file selection
1161 // dialog was cancelled
1162 static int OpenLogFile(wxFile& file, wxString *pFilename, wxWindow *parent)
1163 {
1164     // get the file name
1165     // -----------------
1166     wxString filename = wxSaveFileSelector(wxT("log"), wxT("txt"), wxT("log.txt"), parent);
1167     if ( !filename ) {
1168         // cancelled
1169         return -1;
1170     }
1171
1172     // open file
1173     // ---------
1174     bool bOk;
1175     if ( wxFile::Exists(filename) ) {
1176         bool bAppend = false;
1177         wxString strMsg;
1178         strMsg.Printf(_("Append log to file '%s' (choosing [No] will overwrite it)?"),
1179                       filename.c_str());
1180         switch ( wxMessageBox(strMsg, _("Question"),
1181                               wxICON_QUESTION | wxYES_NO | wxCANCEL) ) {
1182             case wxYES:
1183                 bAppend = true;
1184                 break;
1185
1186             case wxNO:
1187                 bAppend = false;
1188                 break;
1189
1190             case wxCANCEL:
1191                 return -1;
1192
1193             default:
1194                 wxFAIL_MSG(_("invalid message box return value"));
1195         }
1196
1197         if ( bAppend ) {
1198             bOk = file.Open(filename, wxFile::write_append);
1199         }
1200         else {
1201             bOk = file.Create(filename, true /* overwrite */);
1202         }
1203     }
1204     else {
1205         bOk = file.Create(filename);
1206     }
1207
1208     if ( pFilename )
1209         *pFilename = filename;
1210
1211     return bOk;
1212 }
1213
1214 #endif // CAN_SAVE_FILES
1215
1216 #endif // !(wxUSE_LOGGUI || wxUSE_LOGWINDOW)
1217
1218 #if wxUSE_LOG && wxUSE_TEXTCTRL
1219
1220 // ----------------------------------------------------------------------------
1221 // wxLogTextCtrl implementation
1222 // ----------------------------------------------------------------------------
1223
1224 wxLogTextCtrl::wxLogTextCtrl(wxTextCtrl *pTextCtrl)
1225 {
1226     m_pTextCtrl = pTextCtrl;
1227 }
1228
1229 void wxLogTextCtrl::DoLogString(const wxString& szString, time_t WXUNUSED(t))
1230 {
1231     wxString msg;
1232     TimeStamp(&msg);
1233
1234     msg << szString << wxT('\n');
1235     m_pTextCtrl->AppendText(msg);
1236 }
1237
1238 #endif // wxUSE_LOG && wxUSE_TEXTCTRL