]> git.saurik.com Git - wxWidgets.git/blob - src/generic/logg.cpp
projects / wxWidgets.git / blob
? search:


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