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