]> git.saurik.com Git - wxWidgets.git/blame - include/wx/log.h
Use wxWindowMSW instead of wxWindow to fix wxUniv/MSW compilation.
[wxWidgets.git] / include / wx / log.h
CommitLineData
c801d85f 1/////////////////////////////////////////////////////////////////////////////
8ca28fb7 2// Name: wx/log.h
c801d85f
KB
3// Purpose: Assorted wxLogXXX functions, and wxLog (sink for logs)
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 29/01/98
7// RCS-ID: $Id$
8// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
65571936 9// Licence: wxWindows licence
c801d85f
KB
10/////////////////////////////////////////////////////////////////////////////
11
886dd7d2
VZ
12#ifndef _WX_LOG_H_
13#define _WX_LOG_H_
c801d85f 14
df5168c4 15#include "wx/defs.h"
38830220 16
0b4f47a3 17// ----------------------------------------------------------------------------
34085a0d 18// types
0b4f47a3
DS
19// ----------------------------------------------------------------------------
20
34085a0d
VZ
21// NB: this is needed even if wxUSE_LOG == 0
22typedef unsigned long wxLogLevel;
0b4f47a3 23
34085a0d
VZ
24// the trace masks have been superseded by symbolic trace constants, they're
25// for compatibility only and will be removed soon - do NOT use them
26#if WXWIN_COMPATIBILITY_2_8
27 #define wxTraceMemAlloc 0x0001 // trace memory allocation (new/delete)
28 #define wxTraceMessages 0x0002 // trace window messages/X callbacks
29 #define wxTraceResAlloc 0x0004 // trace GDI resource allocation
30 #define wxTraceRefCount 0x0008 // trace various ref counting operations
0b4f47a3 31
34085a0d
VZ
32 #ifdef __WXMSW__
33 #define wxTraceOleCalls 0x0100 // OLE interface calls
34 #endif
546db2a8 35
34085a0d
VZ
36 typedef unsigned long wxTraceMask;
37#endif // WXWIN_COMPATIBILITY_2_8
546db2a8
VZ
38
39// ----------------------------------------------------------------------------
40// headers
41// ----------------------------------------------------------------------------
42
b6e4e44a 43#include "wx/string.h"
c9f78968 44#include "wx/strvararg.h"
b6e4e44a 45
b0d58b0e
VZ
46// ----------------------------------------------------------------------------
47// forward declarations
48// ----------------------------------------------------------------------------
49
50class WXDLLIMPEXP_FWD_BASE wxObject;
51
52#if wxUSE_GUI
53 class WXDLLIMPEXP_FWD_CORE wxFrame;
54#endif // wxUSE_GUI
55
1782be31
VZ
56#if wxUSE_LOG
57
1782be31
VZ
58#include "wx/arrstr.h"
59
9b4da627 60#ifndef __WXPALMOS5__
0e0126c2 61#ifndef __WXWINCE__
1782be31 62 #include <time.h> // for time_t
0e0126c2 63#endif
9b4da627 64#endif // ! __WXPALMOS5__
c30aaf75
VZ
65
66#include "wx/dynarray.h"
af588446 67#include "wx/hashmap.h"
d6b9496a 68
bc73d5ae
VZ
69#if wxUSE_THREADS
70 #include "wx/thread.h"
71#endif // wxUSE_THREADS
72
711f12ef 73// wxUSE_LOG_DEBUG enables the debug log messages
edc73852 74#ifndef wxUSE_LOG_DEBUG
23fb9bf5
VZ
75 #if wxDEBUG_LEVEL
76 #define wxUSE_LOG_DEBUG 1
77 #else // !wxDEBUG_LEVEL
78 #define wxUSE_LOG_DEBUG 0
79 #endif
edc73852
RD
80#endif
81
711f12ef
VZ
82// wxUSE_LOG_TRACE enables the trace messages, they are disabled by default
83#ifndef wxUSE_LOG_TRACE
9d2214dd 84 #if wxDEBUG_LEVEL
711f12ef 85 #define wxUSE_LOG_TRACE 1
9d2214dd 86 #else // !wxDEBUG_LEVEL
711f12ef
VZ
87 #define wxUSE_LOG_TRACE 0
88 #endif
89#endif // wxUSE_LOG_TRACE
90
c602c59b
VZ
91// wxLOG_COMPONENT identifies the component which generated the log record and
92// can be #define'd to a user-defined value when compiling the user code to use
93// component-based filtering (see wxLog::SetComponentLevel())
94#ifndef wxLOG_COMPONENT
95 // this is a variable and not a macro in order to allow the user code to
96 // just #define wxLOG_COMPONENT without #undef'ining it first
97 extern WXDLLIMPEXP_DATA_BASE(const char *) wxLOG_COMPONENT;
98
99 #ifdef WXBUILDING
100 #define wxLOG_COMPONENT "wx"
101 #endif
102#endif
103
9ef3052c
VZ
104// ----------------------------------------------------------------------------
105// constants
106// ----------------------------------------------------------------------------
107
108// different standard log levels (you may also define your own)
90adbcca 109enum wxLogLevelValues
9ef3052c 110{
d6b9496a
VZ
111 wxLOG_FatalError, // program can't continue, abort immediately
112 wxLOG_Error, // a serious error, user must be informed about it
113 wxLOG_Warning, // user is normally informed about it but may be ignored
114 wxLOG_Message, // normal message (i.e. normal output of a non GUI app)
d6b9496a 115 wxLOG_Status, // informational: might go to the status line of GUI app
edc73852 116 wxLOG_Info, // informational message (a.k.a. 'Verbose')
d6b9496a
VZ
117 wxLOG_Debug, // never shown to the user, disabled in release mode
118 wxLOG_Trace, // trace messages are also only enabled in debug mode
119 wxLOG_Progress, // used for progress indicator (not yet)
edc73852 120 wxLOG_User = 100, // user defined levels start here
65ca8c0b 121 wxLOG_Max = 10000
9ef3052c
VZ
122};
123
d6b9496a
VZ
124// symbolic trace masks - wxLogTrace("foo", "some trace message...") will be
125// discarded unless the string "foo" has been added to the list of allowed
126// ones with AddTraceMask()
127
08298395
OK
128#define wxTRACE_MemAlloc wxT("memalloc") // trace memory allocation (new/delete)
129#define wxTRACE_Messages wxT("messages") // trace window messages/X callbacks
130#define wxTRACE_ResAlloc wxT("resalloc") // trace GDI resource allocation
131#define wxTRACE_RefCount wxT("refcount") // trace various ref counting operations
d6b9496a
VZ
132
133#ifdef __WXMSW__
08298395 134 #define wxTRACE_OleCalls wxT("ole") // OLE interface calls
d6b9496a
VZ
135#endif
136
65f19af1 137#include "wx/iosfwrap.h"
470b7da3 138
bc73d5ae
VZ
139// ----------------------------------------------------------------------------
140// information about a log record, i.e. unit of log output
141// ----------------------------------------------------------------------------
142
af588446 143class wxLogRecordInfo
bc73d5ae 144{
af588446
VZ
145public:
146 // default ctor creates an uninitialized object
bc73d5ae
VZ
147 wxLogRecordInfo()
148 {
c602c59b 149 memset(this, 0, sizeof(*this));
af588446
VZ
150 }
151
152 // normal ctor, used by wxLogger specifies the location of the log
153 // statement; its time stamp and thread id are set up here
154 wxLogRecordInfo(const char *filename_,
155 int line_,
c602c59b
VZ
156 const char *func_,
157 const char *component_)
af588446
VZ
158 {
159 filename = filename_;
160 func = func_;
161 line = line_;
c602c59b 162 component = component_;
af588446
VZ
163
164 timestamp = time(NULL);
bc73d5ae
VZ
165
166#if wxUSE_THREADS
af588446 167 threadId = wxThread::GetCurrentId();
bc73d5ae 168#endif // wxUSE_THREADS
af588446
VZ
169
170 m_data = NULL;
171 }
172
173 // we need to define copy ctor and assignment operator because of m_data
174 wxLogRecordInfo(const wxLogRecordInfo& other)
175 {
176 Copy(other);
177 }
178
179 wxLogRecordInfo& operator=(const wxLogRecordInfo& other)
180 {
181 if ( &other != this )
182 {
183 delete m_data;
184 Copy(other);
185 }
186
187 return *this;
bc73d5ae
VZ
188 }
189
af588446
VZ
190 // dtor is non-virtual, this class is not meant to be derived from
191 ~wxLogRecordInfo()
192 {
193 delete m_data;
194 }
bc73d5ae
VZ
195
196
af588446
VZ
197 // the file name and line number of the file where the log record was
198 // generated, if available or NULL and 0 otherwise
199 const char *filename;
200 int line;
201
202 // the name of the function where the log record was generated (may be NULL
203 // if the compiler doesn't support __FUNCTION__)
204 const char *func;
205
c602c59b
VZ
206 // the name of the component which generated this message, may be NULL if
207 // not set (i.e. wxLOG_COMPONENT not defined)
208 const char *component;
209
bc73d5ae
VZ
210 // time of record generation
211 time_t timestamp;
212
213#if wxUSE_THREADS
214 // id of the thread which logged this record
215 wxThreadIdType threadId;
216#endif // wxUSE_THREADS
af588446
VZ
217
218
219 // store an arbitrary value in this record context
220 //
221 // wxWidgets always uses keys starting with "wx.", e.g. "wx.sys_error"
222 void StoreValue(const wxString& key, wxUIntPtr val)
223 {
224 if ( !m_data )
225 m_data = new ExtraData;
226
227 m_data->numValues[key] = val;
228 }
229
230 void StoreValue(const wxString& key, const wxString& val)
231 {
232 if ( !m_data )
233 m_data = new ExtraData;
234
235 m_data->strValues[key] = val;
236 }
237
238
239 // these functions retrieve the value of either numeric or string key,
240 // return false if not found
241 bool GetNumValue(const wxString& key, wxUIntPtr *val) const
242 {
243 if ( !m_data )
244 return false;
245
246 wxStringToNumHashMap::const_iterator it = m_data->numValues.find(key);
247 if ( it == m_data->numValues.end() )
248 return false;
249
250 *val = it->second;
251
252 return true;
253 }
254
255 bool GetStrValue(const wxString& key, wxString *val) const
256 {
257 if ( !m_data )
258 return false;
259
260 wxStringToStringHashMap::const_iterator it = m_data->strValues.find(key);
261 if ( it == m_data->strValues.end() )
262 return false;
263
264 *val = it->second;
265
266 return true;
267 }
268
269private:
270 void Copy(const wxLogRecordInfo& other)
271 {
c602c59b 272 memcpy(this, &other, sizeof(*this));
af588446
VZ
273 if ( other.m_data )
274 m_data = new ExtraData(*other.m_data);
275 }
276
277 // extra data associated with the log record: this is completely optional
278 // and can be used to pass information from the log function to the log
279 // sink (e.g. wxLogSysError() uses this to pass the error code)
280 struct ExtraData
281 {
282 wxStringToNumHashMap numValues;
283 wxStringToStringHashMap strValues;
284 };
285
286 // NULL if not used
287 ExtraData *m_data;
bc73d5ae
VZ
288};
289
af588446
VZ
290#define wxLOG_KEY_TRACE_MASK "wx.trace_mask"
291
232addd1
VZ
292// ----------------------------------------------------------------------------
293// log record: a unit of log output
294// ----------------------------------------------------------------------------
295
296struct wxLogRecord
297{
298 wxLogRecord(wxLogLevel level_,
299 const wxString& msg_,
300 const wxLogRecordInfo& info_)
301 : level(level_),
302 msg(msg_),
303 info(info_)
304 {
305 }
306
307 wxLogLevel level;
308 wxString msg;
309 wxLogRecordInfo info;
310};
311
c801d85f
KB
312// ----------------------------------------------------------------------------
313// derive from this class to redirect (or suppress, or ...) log messages
314// normally, only a single instance of this class exists but it's not enforced
c801d85f 315// ----------------------------------------------------------------------------
d6b9496a 316
bddd7a8d 317class WXDLLIMPEXP_BASE wxLog
c801d85f
KB
318{
319public:
d6b9496a 320 // ctor
bc73d5ae
VZ
321 wxLog() { }
322
323 // make dtor virtual for all derived classes
324 virtual ~wxLog();
325
d6b9496a 326
c602c59b
VZ
327 // log messages selection
328 // ----------------------
329
330 // these functions allow to completely disable all log messages or disable
53ff8df7
VZ
331 // log messages at level less important than specified for the current
332 // thread
d1b20379 333
ba3af101 334 // is logging enabled at all now?
53ff8df7
VZ
335 static bool IsEnabled()
336 {
337#if wxUSE_THREADS
338 if ( !wxThread::IsMain() )
339 return IsThreadLoggingEnabled();
340#endif // wxUSE_THREADS
341
342 return ms_doLog;
343 }
d1b20379
DS
344
345 // change the flag state, return the previous one
53ff8df7
VZ
346 static bool EnableLogging(bool enable = true)
347 {
348#if wxUSE_THREADS
349 if ( !wxThread::IsMain() )
350 return EnableThreadLogging(enable);
351#endif // wxUSE_THREADS
d6b9496a 352
53ff8df7
VZ
353 bool doLogOld = ms_doLog;
354 ms_doLog = enable;
355 return doLogOld;
356 }
c602c59b
VZ
357
358 // return the current global log level
359 static wxLogLevel GetLogLevel() { return ms_logLevel; }
360
361 // set global log level: messages with level > logLevel will not be logged
362 static void SetLogLevel(wxLogLevel logLevel) { ms_logLevel = logLevel; }
363
364 // set the log level for the given component
365 static void SetComponentLevel(const wxString& component, wxLogLevel level);
366
367 // return the effective log level for this component, falling back to
368 // parent component and to the default global log level if necessary
369 //
370 // NB: component argument is passed by value and not const reference in an
371 // attempt to encourage compiler to avoid an extra copy: as we modify
372 // the component internally, we'd create one anyhow and like this it
373 // can be avoided if the string is a temporary anyhow
374 static wxLogLevel GetComponentLevel(wxString component);
375
376
377 // is logging of messages from this component enabled at this level?
378 //
379 // usually always called with wxLOG_COMPONENT as second argument
380 static bool IsLevelEnabled(wxLogLevel level, wxString component)
381 {
382 return IsEnabled() && level <= GetComponentLevel(component);
383 }
384
385
386 // enable/disable messages at wxLOG_Verbose level (only relevant if the
387 // current log level is greater or equal to it)
388 //
389 // notice that verbose mode can be activated by the standard command-line
390 // '--verbose' option
391 static void SetVerbose(bool bVerbose = true) { ms_bVerbose = bVerbose; }
392
393 // check if verbose messages are enabled
394 static bool GetVerbose() { return ms_bVerbose; }
395
396
d6b9496a 397 // message buffering
c602c59b 398 // -----------------
d1b20379
DS
399
400 // flush shows all messages if they're not logged immediately (FILE
e55919d8 401 // and iostream logs don't need it, but wxLogGui does to avoid showing
d1b20379 402 // 17 modal dialogs one after another)
d6b9496a 403 virtual void Flush();
d6b9496a 404
acad886c
VZ
405 // flush the active target if any and also output any pending messages from
406 // background threads
407 static void FlushActive();
1ec5cbf3 408
acad886c
VZ
409 // only one sink is active at each moment get current log target, will call
410 // wxAppTraits::CreateLogTarget() to create one if none exists
d6b9496a 411 static wxLog *GetActiveTarget();
d1b20379 412
acad886c
VZ
413 // change log target, logger may be NULL
414 static wxLog *SetActiveTarget(wxLog *logger);
415
416#if wxUSE_THREADS
417 // change log target for the current thread only, shouldn't be called from
418 // the main thread as it doesn't use thread-specific log target
419 static wxLog *SetThreadActiveTarget(wxLog *logger);
420#endif // wxUSE_THREADS
d6b9496a 421
d1b20379
DS
422 // suspend the message flushing of the main target until the next call
423 // to Resume() - this is mainly for internal use (to prevent wxYield()
424 // from flashing the messages)
2ed3265e 425 static void Suspend() { ms_suspendCount++; }
d1b20379
DS
426
427 // must be called for each Suspend()!
2ed3265e
VZ
428 static void Resume() { ms_suspendCount--; }
429
d1b20379
DS
430 // should GetActiveTarget() try to create a new log object if the
431 // current is NULL?
36bd6902 432 static void DontCreateOnDemand();
d6b9496a 433
e94cd97d
DE
434 // Make GetActiveTarget() create a new log object again.
435 static void DoCreateOnDemand();
436
f9837791
VZ
437 // log the count of repeating messages instead of logging the messages
438 // multiple times
439 static void SetRepetitionCounting(bool bRepetCounting = true)
2e7f3845 440 { ms_bRepetCounting = bRepetCounting; }
f9837791
VZ
441
442 // gets duplicate counting status
443 static bool GetRepetitionCounting() { return ms_bRepetCounting; }
444
d1b20379 445 // add string trace mask
f96233d5 446 static void AddTraceMask(const wxString& str);
d1b20379
DS
447
448 // add string trace mask
d6b9496a 449 static void RemoveTraceMask(const wxString& str);
d1b20379
DS
450
451 // remove all string trace masks
36bd6902 452 static void ClearTraceMasks();
d1b20379 453
f96233d5
VZ
454 // get string trace masks: note that this is MT-unsafe if other threads can
455 // call AddTraceMask() concurrently
55e5154d 456 static const wxArrayString& GetTraceMasks();
d6b9496a 457
7b1bf3ad
VZ
458 // sets the time stamp string format: this is used as strftime() format
459 // string for the log targets which add time stamps to the messages; set
460 // it to empty string to disable time stamping completely.
d993e05b 461 static void SetTimestamp(const wxString& ts) { ms_timestamp = ts; }
d2e1ef19 462
7b1bf3ad
VZ
463 // disable time stamping of log messages
464 static void DisableTimestamp() { SetTimestamp(wxEmptyString); }
465
edc73852 466
d1b20379 467 // is this trace mask in the list?
5a20d2ce 468 static bool IsAllowedTraceMask(const wxString& mask);
d1b20379 469
d1279c9a 470 // get the current timestamp format string (maybe empty)
d993e05b 471 static const wxString& GetTimestamp() { return ms_timestamp; }
d2e1ef19 472
edc73852 473
bc73d5ae
VZ
474
475 // helpers: all functions in this section are mostly for internal use only,
476 // don't call them from your code even if they are not formally deprecated
d1b20379
DS
477
478 // put the time stamp into the string if ms_timestamp != NULL (don't
479 // change it otherwise)
d2e1ef19
VZ
480 static void TimeStamp(wxString *str);
481
bc73d5ae
VZ
482 // these methods should only be called from derived classes DoLogRecord(),
483 // DoLogTextAtLevel() and DoLogText() implementations respectively and
484 // shouldn't be called directly, use logging functions instead
485 void LogRecord(wxLogLevel level,
486 const wxString& msg,
487 const wxLogRecordInfo& info)
efce878a 488 {
bc73d5ae 489 DoLogRecord(level, msg, info);
efce878a
VZ
490 }
491
bc73d5ae
VZ
492 void LogTextAtLevel(wxLogLevel level, const wxString& msg)
493 {
494 DoLogTextAtLevel(level, msg);
495 }
496
497 void LogText(const wxString& msg)
498 {
499 DoLogText(msg);
500 }
501
502 // this is a helper used by wxLogXXX() functions, don't call it directly
503 // and see DoLog() for function to overload in the derived classes
504 static void OnLog(wxLogLevel level,
505 const wxString& msg,
506 const wxLogRecordInfo& info);
507
508 // version called when no information about the location of the log record
509 // generation is available (but the time stamp is), it mainly exists for
510 // backwards compatibility, don't use it in new code
511 static void OnLog(wxLogLevel level, const wxString& msg, time_t t);
512
513 // a helper calling the above overload with current time
514 static void OnLog(wxLogLevel level, const wxString& msg)
515 {
516 OnLog(level, msg, time(NULL));
517 }
c801d85f 518
c801d85f 519
1ec5cbf3 520 // this method exists for backwards compatibility only, don't use
d1b20379 521 bool HasPendingMessages() const { return true; }
1ec5cbf3 522
2e7f3845
VZ
523#if WXWIN_COMPATIBILITY_2_6
524 // this function doesn't do anything any more, don't call it
d65e9d57
VZ
525 static wxDEPRECATED_INLINE(
526 wxChar *SetLogBuffer(wxChar *, size_t = 0), return NULL;
bc73d5ae
VZ
527 );
528#endif // WXWIN_COMPATIBILITY_2_6
2e7f3845 529
34085a0d
VZ
530 // don't use integer masks any more, use string trace masks instead
531#if WXWIN_COMPATIBILITY_2_8
d65e9d57 532 static wxDEPRECATED_INLINE( void SetTraceMask(wxTraceMask ulMask),
34085a0d 533 ms_ulTraceMask = ulMask; )
b356aa55
VZ
534
535 // this one can't be marked deprecated as it's used in our own wxLogger
536 // below but it still is deprecated and shouldn't be used
537 static wxTraceMask GetTraceMask() { return ms_ulTraceMask; }
34085a0d
VZ
538#endif // WXWIN_COMPATIBILITY_2_8
539
1ec5cbf3 540protected:
bc73d5ae
VZ
541 // the logging functions that can be overridden: DoLogRecord() is called
542 // for every "record", i.e. a unit of log output, to be logged and by
543 // default formats the message and passes it to DoLogTextAtLevel() which in
544 // turn passes it to DoLogText() by default
af588446 545
bc73d5ae
VZ
546 // override this method if you want to change message formatting or do
547 // dynamic filtering
548 virtual void DoLogRecord(wxLogLevel level,
549 const wxString& msg,
550 const wxLogRecordInfo& info);
551
552 // override this method to redirect output to different channels depending
553 // on its level only; if even the level doesn't matter, override
554 // DoLogText() instead
555 virtual void DoLogTextAtLevel(wxLogLevel level, const wxString& msg);
556
557 // this function is not pure virtual as it might not be needed if you do
558 // the logging in overridden DoLogRecord() or DoLogTextAtLevel() directly
559 // but if you do not override them in your derived class you must override
560 // this one as the default implementation of it simply asserts
561 virtual void DoLogText(const wxString& msg);
562
563
564 // the rest of the functions are for backwards compatibility only, don't
565 // use them in new code; if you're updating your existing code you need to
566 // switch to overriding DoLogRecord/Text() above (although as long as these
567 // functions exist, log classes using them will continue to work)
5a20d2ce 568#if WXWIN_COMPATIBILITY_2_8
5d88a6b5
VZ
569 wxDEPRECATED_BUT_USED_INTERNALLY(
570 virtual void DoLog(wxLogLevel level, const char *szString, time_t t)
571 );
572
573 wxDEPRECATED_BUT_USED_INTERNALLY(
574 virtual void DoLog(wxLogLevel level, const wchar_t *wzString, time_t t)
575 );
d1b20379 576
5a20d2ce 577 // these shouldn't be used by new code
bc73d5ae
VZ
578 wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
579 virtual void DoLogString(const char *WXUNUSED(szString),
580 time_t WXUNUSED(t)),
ae2070fb 581 wxEMPTY_PARAMETER_VALUE
bc73d5ae
VZ
582 )
583
584 wxDEPRECATED_BUT_USED_INTERNALLY_INLINE(
585 virtual void DoLogString(const wchar_t *WXUNUSED(wzString),
586 time_t WXUNUSED(t)),
ae2070fb 587 wxEMPTY_PARAMETER_VALUE
bc73d5ae 588 )
b99891b0
VZ
589#endif // WXWIN_COMPATIBILITY_2_8
590
c801d85f 591
2064113c 592 // log a message indicating the number of times the previous message was
bc73d5ae
VZ
593 // repeated if previous repetition counter is strictly positive, does
594 // nothing otherwise; return the old value of repetition counter
dbaa16de 595 unsigned LogLastRepeatIfNeeded();
f9837791 596
d6b9496a 597private:
acad886c
VZ
598#if wxUSE_THREADS
599 // called from FlushActive() to really log any buffered messages logged
600 // from the other threads
601 void FlushThreadMessages();
53ff8df7
VZ
602
603 // these functions are called for non-main thread only by IsEnabled() and
604 // EnableLogging() respectively
605 static bool IsThreadLoggingEnabled();
606 static bool EnableThreadLogging(bool enable = true);
acad886c
VZ
607#endif // wxUSE_THREADS
608
5d7526b0
VZ
609 // get the active log target for the main thread, auto-creating it if
610 // necessary
611 //
612 // this is called from GetActiveTarget() and OnLog() when they're called
613 // from the main thread
614 static wxLog *GetMainThreadActiveTarget();
615
acad886c
VZ
616 // called from OnLog() if it's called from the main thread or if we have a
617 // (presumably MT-safe) thread-specific logger and by FlushThreadMessages()
232addd1 618 // when it plays back the buffered messages logged from the other threads
acad886c
VZ
619 void CallDoLogNow(wxLogLevel level,
620 const wxString& msg,
621 const wxLogRecordInfo& info);
232addd1
VZ
622
623
d6b9496a
VZ
624 // static variables
625 // ----------------
06db8ebd 626
2064113c
VZ
627 // if true, don't log the same message multiple times, only log it once
628 // with the number of times it was repeated
f9837791 629 static bool ms_bRepetCounting;
2064113c 630
d6b9496a 631 static wxLog *ms_pLogger; // currently active log sink
d1b20379 632 static bool ms_doLog; // false => all logging disabled
d6b9496a 633 static bool ms_bAutoCreate; // create new log targets on demand?
d1b20379 634 static bool ms_bVerbose; // false => ignore LogInfo messages
fe7b1156 635
edc73852
RD
636 static wxLogLevel ms_logLevel; // limit logging to levels <= ms_logLevel
637
2ed3265e
VZ
638 static size_t ms_suspendCount; // if positive, logs are not flushed
639
d1279c9a 640 // format string for strftime(), if empty, time stamping log messages is
d2e1ef19 641 // disabled
d993e05b 642 static wxString ms_timestamp;
d2e1ef19 643
34085a0d 644#if WXWIN_COMPATIBILITY_2_8
d6b9496a 645 static wxTraceMask ms_ulTraceMask; // controls wxLogTrace behaviour
34085a0d 646#endif // WXWIN_COMPATIBILITY_2_8
c801d85f
KB
647};
648
649// ----------------------------------------------------------------------------
650// "trivial" derivations of wxLog
651// ----------------------------------------------------------------------------
652
711f12ef
VZ
653// log everything except for the debug/trace messages (which are passed to
654// wxMessageOutputDebug) to a buffer
d3fc1755
VZ
655class WXDLLIMPEXP_BASE wxLogBuffer : public wxLog
656{
657public:
658 wxLogBuffer() { }
659
660 // get the string contents with all messages logged
661 const wxString& GetBuffer() const { return m_str; }
662
663 // show the buffer contents to the user in the best possible way (this uses
664 // wxMessageOutputMessageBox) and clear it
665 virtual void Flush();
666
667protected:
bc73d5ae 668 virtual void DoLogTextAtLevel(wxLogLevel level, const wxString& msg);
b99891b0 669
d3fc1755
VZ
670private:
671 wxString m_str;
672
c0c133e1 673 wxDECLARE_NO_COPY_CLASS(wxLogBuffer);
d3fc1755
VZ
674};
675
0f8218d7 676
c801d85f 677// log everything to a "FILE *", stderr by default
bddd7a8d 678class WXDLLIMPEXP_BASE wxLogStderr : public wxLog
c801d85f
KB
679{
680public:
d6b9496a 681 // redirect log output to a FILE
d3b9f782 682 wxLogStderr(FILE *fp = NULL);
c801d85f 683
03147cd0 684protected:
d6b9496a 685 // implement sink function
bc73d5ae 686 virtual void DoLogText(const wxString& msg);
b99891b0 687
d6b9496a 688 FILE *m_fp;
d3fc1755 689
c0c133e1 690 wxDECLARE_NO_COPY_CLASS(wxLogStderr);
c801d85f
KB
691};
692
4bf78aae 693#if wxUSE_STD_IOSTREAM
03147cd0 694
c801d85f 695// log everything to an "ostream", cerr by default
bddd7a8d 696class WXDLLIMPEXP_BASE wxLogStream : public wxLog
c801d85f
KB
697{
698public:
d6b9496a 699 // redirect log output to an ostream
dd107c50 700 wxLogStream(wxSTD ostream *ostr = (wxSTD ostream *) NULL);
c801d85f
KB
701
702protected:
d6b9496a 703 // implement sink function
bc73d5ae 704 virtual void DoLogText(const wxString& msg);
b99891b0 705
d6b9496a 706 // using ptr here to avoid including <iostream.h> from this file
dd107c50 707 wxSTD ostream *m_ostr;
c801d85f 708};
03147cd0
VZ
709
710#endif // wxUSE_STD_IOSTREAM
c801d85f 711
03147cd0
VZ
712// ----------------------------------------------------------------------------
713// /dev/null log target: suppress logging until this object goes out of scope
714// ----------------------------------------------------------------------------
715
716// example of usage:
717/*
718 void Foo()
719 {
720 wxFile file;
721
722 // wxFile.Open() normally complains if file can't be opened, we don't
723 // want it
724 wxLogNull logNo;
725
726 if ( !file.Open("bar") )
727 ... process error ourselves ...
728
729 // ~wxLogNull called, old log sink restored
730 }
731 */
bddd7a8d 732class WXDLLIMPEXP_BASE wxLogNull
03147cd0
VZ
733{
734public:
d1b20379 735 wxLogNull() : m_flagOld(wxLog::EnableLogging(false)) { }
be52b341 736 ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld); }
03147cd0
VZ
737
738private:
739 bool m_flagOld; // the previous value of the wxLog::ms_doLog
740};
741
742// ----------------------------------------------------------------------------
743// chaining log target: installs itself as a log target and passes all
744// messages to the real log target given to it in the ctor but also forwards
745// them to the previously active one
746//
747// note that you don't have to call SetActiveTarget() with this class, it
748// does it itself in its ctor
749// ----------------------------------------------------------------------------
750
bddd7a8d 751class WXDLLIMPEXP_BASE wxLogChain : public wxLog
03147cd0
VZ
752{
753public:
754 wxLogChain(wxLog *logger);
8b30a4e4 755 virtual ~wxLogChain();
03147cd0
VZ
756
757 // change the new log target
758 void SetLog(wxLog *logger);
759
760 // this can be used to temporarily disable (and then reenable) passing
761 // messages to the old logger (by default we do pass them)
762 void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; }
763
764 // are we passing the messages to the previous log target?
765 bool IsPassingMessages() const { return m_bPassMessages; }
766
767 // return the previous log target (may be NULL)
768 wxLog *GetOldLog() const { return m_logOld; }
769
770 // override base class version to flush the old logger as well
771 virtual void Flush();
772
47fe7ff3
JS
773 // call to avoid destroying the old log target
774 void DetachOldLog() { m_logOld = NULL; }
775
03147cd0 776protected:
bc73d5ae
VZ
777 // pass the record to the old logger if needed
778 virtual void DoLogRecord(wxLogLevel level,
779 const wxString& msg,
780 const wxLogRecordInfo& info);
b99891b0 781
03147cd0
VZ
782private:
783 // the current log target
784 wxLog *m_logNew;
785
786 // the previous log target
787 wxLog *m_logOld;
788
789 // do we pass the messages to the old logger?
790 bool m_bPassMessages;
22f3361e 791
c0c133e1 792 wxDECLARE_NO_COPY_CLASS(wxLogChain);
03147cd0
VZ
793};
794
795// a chain log target which uses itself as the new logger
47fe7ff3
JS
796
797#define wxLogPassThrough wxLogInterposer
798
799class WXDLLIMPEXP_BASE wxLogInterposer : public wxLogChain
800{
801public:
802 wxLogInterposer();
803
804private:
c0c133e1 805 wxDECLARE_NO_COPY_CLASS(wxLogInterposer);
47fe7ff3
JS
806};
807
808// a temporary interposer which doesn't destroy the old log target
809// (calls DetachOldLog)
810
811class WXDLLIMPEXP_BASE wxLogInterposerTemp : public wxLogChain
03147cd0
VZ
812{
813public:
47fe7ff3 814 wxLogInterposerTemp();
fc7a2a60
VZ
815
816private:
c0c133e1 817 wxDECLARE_NO_COPY_CLASS(wxLogInterposerTemp);
03147cd0
VZ
818};
819
8ca28fb7 820#if wxUSE_GUI
7e8c564c
VS
821 // include GUI log targets:
822 #include "wx/generic/logg.h"
e90c1d2a 823#endif // wxUSE_GUI
03f38c58 824
af588446
VZ
825// ----------------------------------------------------------------------------
826// wxLogger
827// ----------------------------------------------------------------------------
828
829// wxLogger is a helper class used by wxLogXXX() functions implementation,
830// don't use it directly as it's experimental and subject to change (OTOH it
831// might become public in the future if it's deemed to be useful enough)
832
833// contains information about the context from which a log message originates
834// and provides Log() vararg method which forwards to wxLog::OnLog() and passes
835// this context to it
836class wxLogger
837{
838public:
839 // ctor takes the basic information about the log record
840 wxLogger(wxLogLevel level,
841 const char *filename,
842 int line,
c602c59b
VZ
843 const char *func,
844 const char *component)
af588446 845 : m_level(level),
c602c59b 846 m_info(filename, line, func, component)
af588446
VZ
847 {
848 }
849
850 // store extra data in our log record and return this object itself (so
851 // that further calls to its functions could be chained)
852 template <typename T>
853 wxLogger& Store(const wxString& key, T val)
854 {
855 m_info.StoreValue(key, val);
856 return *this;
857 }
858
859 // hack for "overloaded" wxLogXXX() functions: calling this method
860 // indicates that we may have an extra first argument preceding the format
861 // string and that if we do have it, we should store it in m_info using the
862 // given key (while by default 0 value will be used)
b804f992 863 wxLogger& MaybeStore(const wxString& key, wxUIntPtr value = 0)
af588446
VZ
864 {
865 wxASSERT_MSG( m_optKey.empty(), "can only have one optional value" );
866 m_optKey = key;
867
b804f992 868 m_info.StoreValue(key, value);
af588446
VZ
869 return *this;
870 }
871
872
873 // non-vararg function used by wxVLogXXX():
874
875 // log the message at the level specified in the ctor if this log message
876 // is enabled
877 void LogV(const wxString& format, va_list argptr)
878 {
879 // remember that fatal errors can't be disabled
c602c59b
VZ
880 if ( m_level == wxLOG_FatalError ||
881 wxLog::IsLevelEnabled(m_level, m_info.component) )
af588446
VZ
882 DoCallOnLog(format, argptr);
883 }
884
885 // overloads used by functions with optional leading arguments (whose
886 // values are stored in the key passed to MaybeStore())
887 void LogV(long num, const wxString& format, va_list argptr)
888 {
889 Store(m_optKey, num);
890
891 LogV(format, argptr);
892 }
893
894 void LogV(void *ptr, const wxString& format, va_list argptr)
895 {
896 Store(m_optKey, wxPtrToUInt(ptr));
897
898 LogV(format, argptr);
899 }
900
89d62794
VZ
901 void LogVTrace(const wxString& mask, const wxString& format, va_list argptr)
902 {
903 if ( !wxLog::IsAllowedTraceMask(mask) )
904 return;
905
906 Store(wxLOG_KEY_TRACE_MASK, mask);
907
908 LogV(format, argptr);
909 }
910
af588446
VZ
911
912 // vararg functions used by wxLogXXX():
913
914 // will log the message at the level specified in the ctor
915 //
916 // notice that this function supposes that the caller already checked that
917 // the level was enabled and does no checks itself
918 WX_DEFINE_VARARG_FUNC_VOID
919 (
920 Log,
921 1, (const wxFormatString&),
922 DoLog, DoLogUtf8
923 )
924
925 // same as Log() but with an extra numeric or pointer parameters: this is
926 // used to pass an optional value by storing it in m_info under the name
927 // passed to MaybeStore() and is required to support "overloaded" versions
928 // of wxLogStatus() and wxLogSysError()
929 WX_DEFINE_VARARG_FUNC_VOID
930 (
931 Log,
932 2, (long, const wxFormatString&),
933 DoLogWithNum, DoLogWithNumUtf8
934 )
935
c279530b
VZ
936 // unfortunately we can't use "void *" here as we get overload ambiguities
937 // with Log(wxFormatString, ...) when the first argument is a "char *" or
938 // "wchar_t *" then -- so we only allow passing wxObject here, which is
939 // ugly but fine in practice as this overload is only used by wxLogStatus()
940 // whose first argument is a wxFrame
af588446
VZ
941 WX_DEFINE_VARARG_FUNC_VOID
942 (
943 Log,
c279530b 944 2, (wxObject *, const wxFormatString&),
af588446
VZ
945 DoLogWithPtr, DoLogWithPtrUtf8
946 )
947
948 // log the message at the level specified as its first argument
949 //
950 // as the macros don't have access to the level argument in this case, this
951 // function does check that the level is enabled itself
952 WX_DEFINE_VARARG_FUNC_VOID
953 (
954 LogAtLevel,
955 2, (wxLogLevel, const wxFormatString&),
956 DoLogAtLevel, DoLogAtLevelUtf8
957 )
958
959 // special versions for wxLogTrace() which is passed either string or
ff2e9e2c
VZ
960 // integer mask as first argument determining whether the message should be
961 // logged or not
af588446
VZ
962 WX_DEFINE_VARARG_FUNC_VOID
963 (
964 LogTrace,
965 2, (const wxString&, const wxFormatString&),
966 DoLogTrace, DoLogTraceUtf8
967 )
968
ff2e9e2c
VZ
969#if WXWIN_COMPATIBILITY_2_8
970 WX_DEFINE_VARARG_FUNC_VOID
971 (
972 LogTrace,
973 2, (wxTraceMask, const wxFormatString&),
974 DoLogTraceMask, DoLogTraceMaskUtf8
975 )
976#endif // WXWIN_COMPATIBILITY_2_8
977
af588446
VZ
978#ifdef __WATCOMC__
979 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
980 WX_VARARG_WATCOM_WORKAROUND(void, Log,
981 1, (const wxString&),
982 (wxFormatString(f1)))
983 WX_VARARG_WATCOM_WORKAROUND(void, Log,
984 1, (const wxCStrData&),
985 (wxFormatString(f1)))
986 WX_VARARG_WATCOM_WORKAROUND(void, Log,
987 1, (const char*),
988 (wxFormatString(f1)))
989 WX_VARARG_WATCOM_WORKAROUND(void, Log,
990 1, (const wchar_t*),
991 (wxFormatString(f1)))
992
993 WX_VARARG_WATCOM_WORKAROUND(void, Log,
994 2, (long, const wxString&),
995 (f1, wxFormatString(f2)))
996 WX_VARARG_WATCOM_WORKAROUND(void, Log,
997 2, (long, const wxCStrData&),
998 (f1, wxFormatString(f2)))
999 WX_VARARG_WATCOM_WORKAROUND(void, Log,
1000 2, (long, const char *),
1001 (f1, wxFormatString(f2)))
1002 WX_VARARG_WATCOM_WORKAROUND(void, Log,
1003 2, (long, const wchar_t *),
1004 (f1, wxFormatString(f2)))
1005
1006 WX_VARARG_WATCOM_WORKAROUND(void, Log,
c279530b 1007 2, (wxObject *, const wxString&),
af588446
VZ
1008 (f1, wxFormatString(f2)))
1009 WX_VARARG_WATCOM_WORKAROUND(void, Log,
c279530b 1010 2, (wxObject *, const wxCStrData&),
af588446
VZ
1011 (f1, wxFormatString(f2)))
1012 WX_VARARG_WATCOM_WORKAROUND(void, Log,
c279530b 1013 2, (wxObject *, const char *),
af588446
VZ
1014 (f1, wxFormatString(f2)))
1015 WX_VARARG_WATCOM_WORKAROUND(void, Log,
c279530b 1016 2, (wxObject *, const wchar_t *),
af588446
VZ
1017 (f1, wxFormatString(f2)))
1018
1019 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel,
1020 2, (wxLogLevel, const wxString&),
1021 (f1, wxFormatString(f2)))
1022 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel,
1023 2, (wxLogLevel, const wxCStrData&),
1024 (f1, wxFormatString(f2)))
1025 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel,
1026 2, (wxLogLevel, const char *),
1027 (f1, wxFormatString(f2)))
1028 WX_VARARG_WATCOM_WORKAROUND(void, LogAtLevel,
1029 2, (wxLogLevel, const wchar_t *),
1030 (f1, wxFormatString(f2)))
1031
1032 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1033 2, (const wxString&, const wxString&),
1034 (f1, wxFormatString(f2)))
1035 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1036 2, (const wxString&, const wxCStrData&),
1037 (f1, wxFormatString(f2)))
1038 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1039 2, (const wxString&, const char *),
1040 (f1, wxFormatString(f2)))
1041 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1042 2, (const wxString&, const wchar_t *),
1043 (f1, wxFormatString(f2)))
ff2e9e2c
VZ
1044
1045#if WXWIN_COMPATIBILITY_2_8
1046 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1047 2, (wxTraceMask, wxTraceMask),
1048 (f1, wxFormatString(f2)))
1049 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1050 2, (wxTraceMask, const wxCStrData&),
1051 (f1, wxFormatString(f2)))
1052 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1053 2, (wxTraceMask, const char *),
1054 (f1, wxFormatString(f2)))
1055 WX_VARARG_WATCOM_WORKAROUND(void, LogTrace,
1056 2, (wxTraceMask, const wchar_t *),
1057 (f1, wxFormatString(f2)))
1058#endif // WXWIN_COMPATIBILITY_2_8
af588446
VZ
1059#endif // __WATCOMC__
1060
1061private:
1062#if !wxUSE_UTF8_LOCALE_ONLY
1063 void DoLog(const wxChar *format, ...)
1064 {
1065 va_list argptr;
1066 va_start(argptr, format);
1067 DoCallOnLog(format, argptr);
1068 va_end(argptr);
1069 }
1070
1071 void DoLogWithNum(long num, const wxChar *format, ...)
1072 {
1073 Store(m_optKey, num);
1074
1075 va_list argptr;
1076 va_start(argptr, format);
1077 DoCallOnLog(format, argptr);
1078 va_end(argptr);
1079 }
1080
1081 void DoLogWithPtr(void *ptr, const wxChar *format, ...)
1082 {
1083 Store(m_optKey, wxPtrToUInt(ptr));
1084
1085 va_list argptr;
1086 va_start(argptr, format);
1087 DoCallOnLog(format, argptr);
1088 va_end(argptr);
1089 }
1090
1091 void DoLogAtLevel(wxLogLevel level, const wxChar *format, ...)
1092 {
c602c59b 1093 if ( !wxLog::IsLevelEnabled(level, m_info.component) )
af588446
VZ
1094 return;
1095
1096 va_list argptr;
1097 va_start(argptr, format);
1098 DoCallOnLog(level, format, argptr);
1099 va_end(argptr);
1100 }
1101
1102 void DoLogTrace(const wxString& mask, const wxChar *format, ...)
1103 {
1104 if ( !wxLog::IsAllowedTraceMask(mask) )
1105 return;
1106
1107 Store(wxLOG_KEY_TRACE_MASK, mask);
1108
1109 va_list argptr;
1110 va_start(argptr, format);
1111 DoCallOnLog(format, argptr);
1112 va_end(argptr);
1113 }
ff2e9e2c
VZ
1114
1115#if WXWIN_COMPATIBILITY_2_8
1116 void DoLogTraceMask(wxTraceMask mask, const wxChar *format, ...)
1117 {
1118 if ( (wxLog::GetTraceMask() & mask) != mask )
1119 return;
1120
1121 Store(wxLOG_KEY_TRACE_MASK, mask);
1122
1123 va_list argptr;
1124 va_start(argptr, format);
1125 DoCallOnLog(format, argptr);
1126 va_end(argptr);
1127 }
1128#endif // WXWIN_COMPATIBILITY_2_8
af588446
VZ
1129#endif // !wxUSE_UTF8_LOCALE_ONLY
1130
1131#if wxUSE_UNICODE_UTF8
1132 void DoLogUtf8(const char *format, ...)
1133 {
1134 va_list argptr;
1135 va_start(argptr, format);
1136 DoCallOnLog(format, argptr);
1137 va_end(argptr);
1138 }
1139
1140 void DoLogWithNumUtf8(long num, const char *format, ...)
1141 {
1142 Store(m_optKey, num);
1143
1144 va_list argptr;
1145 va_start(argptr, format);
1146 DoCallOnLog(format, argptr);
1147 va_end(argptr);
1148 }
1149
1150 void DoLogWithPtrUtf8(void *ptr, const char *format, ...)
1151 {
1152 Store(m_optKey, wxPtrToUInt(ptr));
1153
1154 va_list argptr;
1155 va_start(argptr, format);
1156 DoCallOnLog(format, argptr);
1157 va_end(argptr);
1158 }
1159
1160 void DoLogAtLevelUtf8(wxLogLevel level, const char *format, ...)
1161 {
c602c59b 1162 if ( !wxLog::IsLevelEnabled(level, m_info.component) )
af588446
VZ
1163 return;
1164
1165 va_list argptr;
1166 va_start(argptr, format);
1167 DoCallOnLog(level, format, argptr);
1168 va_end(argptr);
1169 }
1170
1171 void DoLogTraceUtf8(const wxString& mask, const char *format, ...)
1172 {
1173 if ( !wxLog::IsAllowedTraceMask(mask) )
1174 return;
1175
1176 Store(wxLOG_KEY_TRACE_MASK, mask);
1177
1178 va_list argptr;
1179 va_start(argptr, format);
1180 DoCallOnLog(format, argptr);
1181 va_end(argptr);
1182 }
ff2e9e2c
VZ
1183
1184#if WXWIN_COMPATIBILITY_2_8
1185 void DoLogTraceMaskUtf8(wxTraceMask mask, const char *format, ...)
1186 {
1187 if ( (wxLog::GetTraceMask() & mask) != mask )
1188 return;
1189
1190 Store(wxLOG_KEY_TRACE_MASK, mask);
1191
1192 va_list argptr;
1193 va_start(argptr, format);
1194 DoCallOnLog(format, argptr);
1195 va_end(argptr);
1196 }
1197#endif // WXWIN_COMPATIBILITY_2_8
af588446
VZ
1198#endif // wxUSE_UNICODE_UTF8
1199
1200 void DoCallOnLog(wxLogLevel level, const wxString& format, va_list argptr)
1201 {
1202 wxLog::OnLog(level, wxString::FormatV(format, argptr), m_info);
1203 }
1204
1205 void DoCallOnLog(const wxString& format, va_list argptr)
1206 {
b804f992 1207 DoCallOnLog(m_level, format, argptr);
af588446
VZ
1208 }
1209
1210
1211 const wxLogLevel m_level;
1212 wxLogRecordInfo m_info;
1213
1214 wxString m_optKey;
1215
1216 wxDECLARE_NO_COPY_CLASS(wxLogger);
1217};
1218
c801d85f
KB
1219// ============================================================================
1220// global functions
1221// ============================================================================
1222
88ac883a
VZ
1223// ----------------------------------------------------------------------------
1224// get error code/error message from system in a portable way
1225// ----------------------------------------------------------------------------
1226
1227// return the last system error code
bddd7a8d 1228WXDLLIMPEXP_BASE unsigned long wxSysErrorCode();
c11d62a6 1229
88ac883a 1230// return the error message for given (or last if 0) error code
bddd7a8d 1231WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0);
88ac883a 1232
c11d62a6 1233// ----------------------------------------------------------------------------
af588446
VZ
1234// define wxLog<level>() functions which can be used by application instead of
1235// stdio, iostream &c for log messages for easy redirection
c11d62a6 1236// ----------------------------------------------------------------------------
c801d85f 1237
af588446
VZ
1238/*
1239 The code below is unreadable because it (unfortunately unavoidably)
1240 contains a lot of macro magic but all it does is to define wxLogXXX() such
1241 that you can call them as vararg functions to log a message at the
1242 corresponding level.
1243
1244 More precisely, it defines:
1245
1246 - wxLog{FatalError,Error,Warning,Message,Verbose,Debug}() functions
1247 taking the format string and additional vararg arguments if needed.
1248 - wxLogGeneric(wxLogLevel level, const wxString& format, ...) which
1249 takes the log level explicitly.
1250 - wxLogSysError(const wxString& format, ...) and wxLogSysError(long
1251 err, const wxString& format, ...) which log a wxLOG_Error severity
1252 message with the error message corresponding to the system error code
1253 err or the last error.
1254 - wxLogStatus(const wxString& format, ...) which logs the message into
1255 the status bar of the main application window and its overload
1256 wxLogStatus(wxFrame *frame, const wxString& format, ...) which logs it
1257 into the status bar of the specified frame.
1258 - wxLogTrace(Mask mask, const wxString& format, ...) which only logs
1259 the message is the specified mask is enabled. This comes in two kinds:
1260 Mask can be a wxString or a long. Both are deprecated.
1261
1262 In addition, wxVLogXXX() versions of all the functions above are also
1263 defined. They take a va_list argument instead of "...".
1264 */
2523e9b7 1265
af588446
VZ
1266// creates wxLogger object for the current location
1267#define wxMAKE_LOGGER(level) \
c602c59b 1268 wxLogger(wxLOG_##level, __FILE__, __LINE__, __WXFUNCTION__, wxLOG_COMPONENT)
2523e9b7 1269
af588446
VZ
1270// this macro generates the expression which logs whatever follows it in
1271// parentheses at the level specified as argument
1272#define wxDO_LOG(level) wxMAKE_LOGGER(level).Log
c9f78968 1273
af588446
VZ
1274// this is the non-vararg equivalent
1275#define wxDO_LOGV(level, format, argptr) \
1276 wxMAKE_LOGGER(level).LogV(format, argptr)
2523e9b7 1277
af588446
VZ
1278// this macro declares wxLog<level>() macro which logs whatever follows it if
1279// logging at specified level is enabled (notice that if it is false, the
1280// following arguments are not even evaluated which is good as it avoids
1281// unnecessary overhead)
1282//
1283// Note: the strange if/else construct is needed to make the following code
1284//
1285// if ( cond )
1286// wxLogError("!!!");
1287// else
1288// ...
1289//
1290// work as expected, without it the second "else" would match the "if"
1291// inside wxLogError(). Unfortunately code like
1292//
1293// if ( cond )
1294// wxLogError("!!!");
1295//
1296// now provokes "suggest explicit braces to avoid ambiguous 'else'"
1297// warnings from g++ 4.3 and later with -Wparentheses on but they can be
1298// easily fixed by adding curly braces around wxLogError() and at least
1299// the code still does do the right thing.
1300#define wxDO_LOG_IF_ENABLED(level) \
c602c59b 1301 if ( !wxLog::IsLevelEnabled(wxLOG_##level, wxLOG_COMPONENT) ) \
af588446
VZ
1302 {} \
1303 else \
1304 wxDO_LOG(level)
1305
1306// wxLogFatalError() is special as it can't be disabled
03647350 1307#define wxLogFatalError wxDO_LOG(FatalError)
af588446
VZ
1308#define wxVLogFatalError(format, argptr) wxDO_LOGV(FatalError, format, argptr)
1309
1310#define wxLogError wxDO_LOG_IF_ENABLED(Error)
1311#define wxVLogError(format, argptr) wxDO_LOGV(Error, format, argptr)
1312
1313#define wxLogWarning wxDO_LOG_IF_ENABLED(Warning)
1314#define wxVLogWarning(format, argptr) wxDO_LOGV(Warning, format, argptr)
1315
1316#define wxLogMessage wxDO_LOG_IF_ENABLED(Message)
1317#define wxVLogMessage(format, argptr) wxDO_LOGV(Message, format, argptr)
1318
1319// this one is special as it only logs if we're in verbose mode
1320#define wxLogVerbose \
c602c59b
VZ
1321 if ( !(wxLog::IsLevelEnabled(wxLOG_Info, wxLOG_COMPONENT) && \
1322 wxLog::GetVerbose()) ) \
af588446
VZ
1323 {} \
1324 else \
1325 wxDO_LOG(Info)
1326#define wxVLogVerbose(format, argptr) \
c602c59b
VZ
1327 if ( !(wxLog::IsLevelEnabled(wxLOG_Info, wxLOG_COMPONENT) && \
1328 wxLog::GetVerbose()) ) \
af588446
VZ
1329 {} \
1330 else \
1331 wxDO_LOGV(Info, format, argptr)
1332
1333// deprecated synonyms for wxLogVerbose() and wxVLogVerbose()
1334#define wxLogInfo wxLogVerbose
1335#define wxVLogInfo wxVLogVerbose
1336
1337
1338// another special case: the level is passed as first argument of the function
1339// and so is not available to the macro
1340//
1341// notice that because of this, arguments of wxLogGeneric() are currently
1342// always evaluated, unlike for the other log functions
1343#define wxLogGeneric wxMAKE_LOGGER(Max).LogAtLevel
1344#define wxVLogGeneric(level, format, argptr) \
c602c59b 1345 if ( !wxLog::IsLevelEnabled(wxLOG_##level, wxLOG_COMPONENT) ) \
af588446
VZ
1346 {} \
1347 else \
1348 wxDO_LOGV(level, format, argptr)
1349
1350
1351// wxLogSysError() needs to stash the error code value in the log record info
1352// so it needs special handling too; additional complications arise because the
1353// error code may or not be present as the first argument
b804f992
VZ
1354//
1355// notice that we unfortunately can't avoid the call to wxSysErrorCode() even
1356// though it may be unneeded if an explicit error code is passed to us because
1357// the message might not be logged immediately (e.g. it could be queued for
1358// logging from the main thread later) and so we can't to wait until it is
1359// logged to determine whether we have last error or not as it will be too late
1360// and it will have changed already by then (in fact it even changes when
1361// wxString::Format() is called because of vsnprintf() inside it so it can
1362// change even much sooner)
af588446
VZ
1363#define wxLOG_KEY_SYS_ERROR_CODE "wx.sys_error"
1364
1365#define wxLogSysError \
c602c59b 1366 if ( !wxLog::IsLevelEnabled(wxLOG_Error, wxLOG_COMPONENT) ) \
af588446
VZ
1367 {} \
1368 else \
b804f992
VZ
1369 wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE, \
1370 wxSysErrorCode()).Log
af588446
VZ
1371
1372// unfortunately we can't have overloaded macros so we can't define versions
1373// both with and without error code argument and have to rely on LogV()
1374// overloads in wxLogger to select between them
1375#define wxVLogSysError \
b804f992
VZ
1376 wxMAKE_LOGGER(Error).MaybeStore(wxLOG_KEY_SYS_ERROR_CODE, \
1377 wxSysErrorCode()).LogV
af588446
VZ
1378
1379#if wxUSE_GUI
1380 // wxLogStatus() is similar to wxLogSysError() as it allows to optionally
1381 // specify the frame to which the message should go
1382 #define wxLOG_KEY_FRAME "wx.frame"
1383
1384 #define wxLogStatus \
c602c59b 1385 if ( !wxLog::IsLevelEnabled(wxLOG_Status, wxLOG_COMPONENT) ) \
af588446
VZ
1386 {} \
1387 else \
1388 wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).Log
1389
1390 #define wxVLogStatus(format, argptr) \
1391 wxMAKE_LOGGER(Status).MaybeStore(wxLOG_KEY_FRAME).LogV
1392#endif // wxUSE_GUI
2523e9b7 1393
c9f78968 1394
88ac883a
VZ
1395#else // !wxUSE_LOG
1396
711f12ef
VZ
1397#undef wxUSE_LOG_DEBUG
1398#define wxUSE_LOG_DEBUG 0
1399
1400#undef wxUSE_LOG_TRACE
1401#define wxUSE_LOG_TRACE 0
1402
99fda03a
VS
1403#if defined(__WATCOMC__) || defined(__MINGW32__)
1404 // Mingw has similar problem with wxLogSysError:
1405 #define WX_WATCOM_OR_MINGW_ONLY_CODE( x ) x
1406#else
1407 #define WX_WATCOM_OR_MINGW_ONLY_CODE( x )
1408#endif
1409
af588446
VZ
1410// define macros for defining log functions which do nothing at all
1411//
1412// WX_WATCOM_ONLY_CODE is needed to work around
1413// http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1414#define wxDEFINE_EMPTY_LOG_FUNCTION(level) \
b0d58b0e 1415 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxFormatString&)) \
2523e9b7
VS
1416 WX_WATCOM_ONLY_CODE( \
1417 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const char*)) \
1418 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wchar_t*)) \
1419 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxCStrData&)) \
1420 ) \
b0d58b0e 1421 inline void wxVLog##level(const wxFormatString& WXUNUSED(format), \
59a14f69 1422 va_list WXUNUSED(argptr)) { } \
c9f78968 1423
af588446 1424#define wxDEFINE_EMPTY_LOG_FUNCTION2(level, argclass) \
b0d58b0e 1425 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxFormatString&)) \
99fda03a 1426 WX_WATCOM_OR_MINGW_ONLY_CODE( \
2523e9b7
VS
1427 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const char*)) \
1428 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wchar_t*)) \
1429 WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxCStrData&)) \
1430 ) \
c9f78968 1431 inline void wxVLog##level(argclass WXUNUSED(arg), \
b0d58b0e 1432 const wxFormatString& WXUNUSED(format), \
59a14f69 1433 va_list WXUNUSED(argptr)) {}
2523e9b7 1434
af588446
VZ
1435wxDEFINE_EMPTY_LOG_FUNCTION(FatalError);
1436wxDEFINE_EMPTY_LOG_FUNCTION(Error);
1437wxDEFINE_EMPTY_LOG_FUNCTION(SysError);
1438wxDEFINE_EMPTY_LOG_FUNCTION2(SysError, long);
1439wxDEFINE_EMPTY_LOG_FUNCTION(Warning);
1440wxDEFINE_EMPTY_LOG_FUNCTION(Message);
1441wxDEFINE_EMPTY_LOG_FUNCTION(Info);
1442wxDEFINE_EMPTY_LOG_FUNCTION(Verbose);
1443
1444wxDEFINE_EMPTY_LOG_FUNCTION2(Generic, wxLogLevel);
1445
1446#if wxUSE_GUI
1447 wxDEFINE_EMPTY_LOG_FUNCTION(Status);
1448 wxDEFINE_EMPTY_LOG_FUNCTION2(Status, wxFrame *);
1449#endif // wxUSE_GUI
1450
e30285ab 1451// Empty Class to fake wxLogNull
bddd7a8d 1452class WXDLLIMPEXP_BASE wxLogNull
e30285ab
VZ
1453{
1454public:
886dd7d2 1455 wxLogNull() { }
e30285ab
VZ
1456};
1457
1458// Dummy macros to replace some functions.
1459#define wxSysErrorCode() (unsigned long)0
1460#define wxSysErrorMsg( X ) (const wxChar*)NULL
1461
1462// Fake symbolic trace masks... for those that are used frequently
fda7962d 1463#define wxTRACE_OleCalls wxEmptyString // OLE interface calls
e30285ab 1464
88ac883a 1465#endif // wxUSE_LOG/!wxUSE_LOG
bdeb1f0d 1466
711f12ef
VZ
1467
1468// debug functions can be completely disabled in optimized builds
1469
1470// if these log functions are disabled, we prefer to define them as (empty)
1471// variadic macros as this completely removes them and their argument
1472// evaluation from the object code but if this is not supported by compiler we
1473// use empty inline functions instead (defining them as nothing would result in
1474// compiler warnings)
1475//
1476// note that making wxVLogDebug/Trace() themselves (empty inline) functions is
1477// a bad idea as some compilers are stupid enough to not inline even empty
1478// functions if their parameters are complicated enough, but by defining them
1479// as an empty inline function we ensure that even dumbest compilers optimise
1480// them away
1481#ifdef __BORLANDC__
1482 // but Borland gives "W8019: Code has no effect" for wxLogNop() so we need
1483 // to define it differently for it to avoid these warnings (same problem as
1484 // with wxUnusedVar())
1485 #define wxLogNop() { }
1486#else
1487 inline void wxLogNop() { }
1488#endif
1489
1490#if wxUSE_LOG_DEBUG
af588446
VZ
1491 #define wxLogDebug wxDO_LOG_IF_ENABLED(Debug)
1492 #define wxVLogDebug(format, argptr) wxDO_LOGV(Debug, format, argptr)
711f12ef
VZ
1493#else // !wxUSE_LOG_DEBUG
1494 #define wxVLogDebug(fmt, valist) wxLogNop()
d6b9496a 1495
711f12ef
VZ
1496 #ifdef HAVE_VARIADIC_MACROS
1497 #define wxLogDebug(fmt, ...) wxLogNop()
1498 #else // !HAVE_VARIADIC_MACROS
b0d58b0e 1499 WX_DEFINE_VARARG_FUNC_NOP(wxLogDebug, 1, (const wxFormatString&))
711f12ef
VZ
1500 #endif
1501#endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG
d6b9496a 1502
711f12ef 1503#if wxUSE_LOG_TRACE
af588446 1504 #define wxLogTrace \
c602c59b 1505 if ( !wxLog::IsLevelEnabled(wxLOG_Trace, wxLOG_COMPONENT) ) \
af588446
VZ
1506 {} \
1507 else \
1508 wxMAKE_LOGGER(Trace).LogTrace
89d62794
VZ
1509 #define wxVLogTrace \
1510 if ( !wxLog::IsLevelEnabled(wxLOG_Trace, wxLOG_COMPONENT) ) \
1511 {} \
1512 else \
1513 wxMAKE_LOGGER(Trace).LogVTrace
711f12ef 1514#else // !wxUSE_LOG_TRACE
388a1f66 1515 #define wxVLogTrace(mask, fmt, valist) wxLogNop()
ca766534
VS
1516
1517 #ifdef HAVE_VARIADIC_MACROS
388a1f66 1518 #define wxLogTrace(mask, fmt, ...) wxLogNop()
ca766534 1519 #else // !HAVE_VARIADIC_MACROS
69e3710e 1520 #if WXWIN_COMPATIBILITY_2_8
b0d58b0e 1521 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (wxTraceMask, const wxFormatString&))
69e3710e 1522 #endif
b0d58b0e 1523 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wxString&, const wxFormatString&))
44be939a
VS
1524 #ifdef __WATCOMC__
1525 // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
1526 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const char*, const char*))
1527 WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wchar_t*, const wchar_t*))
1528 #endif
ca766534 1529 #endif // HAVE_VARIADIC_MACROS/!HAVE_VARIADIC_MACROS
711f12ef 1530#endif // wxUSE_LOG_TRACE/!wxUSE_LOG_TRACE
c801d85f 1531
c11d62a6
VZ
1532// wxLogFatalError helper: show the (fatal) error to the user in a safe way,
1533// i.e. without using wxMessageBox() for example because it could crash
bddd7a8d 1534void WXDLLIMPEXP_BASE
886dd7d2 1535wxSafeShowMessage(const wxString& title, const wxString& text);
c11d62a6 1536
88ac883a
VZ
1537// ----------------------------------------------------------------------------
1538// debug only logging functions: use them with API name and error code
1539// ----------------------------------------------------------------------------
c801d85f 1540
23fb9bf5 1541#if wxUSE_LOG_DEBUG
42e69d6b
VZ
1542 // make life easier for people using VC++ IDE: clicking on the message
1543 // will take us immediately to the place of the failed API
1544#ifdef __VISUALC__
4b7f2165
VZ
1545 #define wxLogApiError(api, rc) \
1546 wxLogDebug(wxT("%s(%d): '%s' failed with error 0x%08lx (%s)."), \
0accd1cf 1547 __FILE__, __LINE__, api, \
8b94d999 1548 (long)rc, wxSysErrorMsg(rc))
42e69d6b 1549#else // !VC++
4b7f2165 1550 #define wxLogApiError(api, rc) \
18da7cf2
VZ
1551 wxLogDebug(wxT("In file %s at line %d: '%s' failed with ") \
1552 wxT("error 0x%08lx (%s)."), \
0accd1cf 1553 __FILE__, __LINE__, api, \
8b94d999 1554 (long)rc, wxSysErrorMsg(rc))
42e69d6b
VZ
1555#endif // VC++/!VC++
1556
1557 #define wxLogLastError(api) wxLogApiError(api, wxSysErrorCode())
1558
23fb9bf5 1559#else // !wxUSE_LOG_DEBUG
388a1f66
VZ
1560 #define wxLogApiError(api, err) wxLogNop()
1561 #define wxLogLastError(api) wxLogNop()
23fb9bf5 1562#endif // wxUSE_LOG_DEBUG/!wxUSE_LOG_DEBUG
c801d85f 1563
a619fa3f
DE
1564// wxCocoa has additiional trace masks
1565#if defined(__WXCOCOA__)
1566#include "wx/cocoa/log.h"
1567#endif
1568
82e77a80
VS
1569#ifdef WX_WATCOM_ONLY_CODE
1570 #undef WX_WATCOM_ONLY_CODE
1571#endif
1572
7d9550df 1573// macro which disables debug logging in release builds: this is done by
e4431849 1574// default by wxIMPLEMENT_APP() so usually it doesn't need to be used explicitly
ff464152 1575#if defined(NDEBUG) && wxUSE_LOG_DEBUG
7d9550df
VZ
1576 #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD() \
1577 wxLog::SetLogLevel(wxLOG_Info)
1578#else // !NDEBUG
1579 #define wxDISABLE_DEBUG_LOGGING_IN_RELEASE_BUILD()
1580#endif // NDEBUG/!NDEBUG
1581
34138703 1582#endif // _WX_LOG_H_
04662def 1583