]>
Commit | Line | Data |
---|---|---|
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 |
22 | typedef 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 | ||
50 | class 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 | 109 | enum 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 | 143 | class wxLogRecordInfo |
bc73d5ae | 144 | { |
af588446 VZ |
145 | public: |
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 | ||
269 | private: | |
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 | ||
296 | struct 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 | 317 | class WXDLLIMPEXP_BASE wxLog |
c801d85f KB |
318 | { |
319 | public: | |
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 | 540 | protected: |
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 | 597 | private: |
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 |
655 | class WXDLLIMPEXP_BASE wxLogBuffer : public wxLog |
656 | { | |
657 | public: | |
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 | ||
667 | protected: | |
bc73d5ae | 668 | virtual void DoLogTextAtLevel(wxLogLevel level, const wxString& msg); |
b99891b0 | 669 | |
d3fc1755 VZ |
670 | private: |
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 | 678 | class WXDLLIMPEXP_BASE wxLogStderr : public wxLog |
c801d85f KB |
679 | { |
680 | public: | |
d6b9496a | 681 | // redirect log output to a FILE |
d3b9f782 | 682 | wxLogStderr(FILE *fp = NULL); |
c801d85f | 683 | |
03147cd0 | 684 | protected: |
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 | 696 | class WXDLLIMPEXP_BASE wxLogStream : public wxLog |
c801d85f KB |
697 | { |
698 | public: | |
d6b9496a | 699 | // redirect log output to an ostream |
dd107c50 | 700 | wxLogStream(wxSTD ostream *ostr = (wxSTD ostream *) NULL); |
c801d85f KB |
701 | |
702 | protected: | |
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 | 732 | class WXDLLIMPEXP_BASE wxLogNull |
03147cd0 VZ |
733 | { |
734 | public: | |
d1b20379 | 735 | wxLogNull() : m_flagOld(wxLog::EnableLogging(false)) { } |
be52b341 | 736 | ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld); } |
03147cd0 VZ |
737 | |
738 | private: | |
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 | 751 | class WXDLLIMPEXP_BASE wxLogChain : public wxLog |
03147cd0 VZ |
752 | { |
753 | public: | |
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 | 776 | protected: |
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 |
782 | private: |
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 | ||
799 | class WXDLLIMPEXP_BASE wxLogInterposer : public wxLogChain | |
800 | { | |
801 | public: | |
802 | wxLogInterposer(); | |
803 | ||
804 | private: | |
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 | ||
811 | class WXDLLIMPEXP_BASE wxLogInterposerTemp : public wxLogChain | |
03147cd0 VZ |
812 | { |
813 | public: | |
47fe7ff3 | 814 | wxLogInterposerTemp(); |
fc7a2a60 VZ |
815 | |
816 | private: | |
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 | |
836 | class wxLogger | |
837 | { | |
838 | public: | |
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 | ||
1061 | private: | |
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 | 1228 | WXDLLIMPEXP_BASE unsigned long wxSysErrorCode(); |
c11d62a6 | 1229 | |
88ac883a | 1230 | // return the error message for given (or last if 0) error code |
bddd7a8d | 1231 | WXDLLIMPEXP_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 |
1435 | wxDEFINE_EMPTY_LOG_FUNCTION(FatalError); |
1436 | wxDEFINE_EMPTY_LOG_FUNCTION(Error); | |
1437 | wxDEFINE_EMPTY_LOG_FUNCTION(SysError); | |
1438 | wxDEFINE_EMPTY_LOG_FUNCTION2(SysError, long); | |
1439 | wxDEFINE_EMPTY_LOG_FUNCTION(Warning); | |
1440 | wxDEFINE_EMPTY_LOG_FUNCTION(Message); | |
1441 | wxDEFINE_EMPTY_LOG_FUNCTION(Info); | |
1442 | wxDEFINE_EMPTY_LOG_FUNCTION(Verbose); | |
1443 | ||
1444 | wxDEFINE_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 | 1452 | class WXDLLIMPEXP_BASE wxLogNull |
e30285ab VZ |
1453 | { |
1454 | public: | |
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 | 1534 | void WXDLLIMPEXP_BASE |
886dd7d2 | 1535 | wxSafeShowMessage(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 |