]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/log.h | |
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> | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_LOG_H_ | |
13 | #define _WX_LOG_H_ | |
14 | ||
15 | #include "wx/defs.h" | |
16 | ||
17 | #include "wx/thread.h" | |
18 | ||
19 | // ---------------------------------------------------------------------------- | |
20 | // common constants for use in wxUSE_LOG/!wxUSE_LOG | |
21 | // ---------------------------------------------------------------------------- | |
22 | ||
23 | // the trace masks have been superceded by symbolic trace constants, they're | |
24 | // for compatibility only andwill be removed soon - do NOT use them | |
25 | ||
26 | // meaning of different bits of the trace mask (which allows selectively | |
27 | // enable/disable some trace messages) | |
28 | #define wxTraceMemAlloc 0x0001 // trace memory allocation (new/delete) | |
29 | #define wxTraceMessages 0x0002 // trace window messages/X callbacks | |
30 | #define wxTraceResAlloc 0x0004 // trace GDI resource allocation | |
31 | #define wxTraceRefCount 0x0008 // trace various ref counting operations | |
32 | ||
33 | #ifdef __WXMSW__ | |
34 | #define wxTraceOleCalls 0x0100 // OLE interface calls | |
35 | #endif | |
36 | ||
37 | // ---------------------------------------------------------------------------- | |
38 | // types | |
39 | // ---------------------------------------------------------------------------- | |
40 | ||
41 | // NB: these types are needed even if wxUSE_LOG == 0 | |
42 | typedef unsigned long wxTraceMask; | |
43 | typedef unsigned long wxLogLevel; | |
44 | ||
45 | // ---------------------------------------------------------------------------- | |
46 | // headers | |
47 | // ---------------------------------------------------------------------------- | |
48 | ||
49 | #include "wx/string.h" | |
50 | #include "wx/strvararg.h" | |
51 | ||
52 | #if wxUSE_LOG | |
53 | ||
54 | #include "wx/arrstr.h" | |
55 | ||
56 | #ifndef __WXWINCE__ | |
57 | #include <time.h> // for time_t | |
58 | #endif | |
59 | ||
60 | #include "wx/dynarray.h" | |
61 | ||
62 | #ifndef wxUSE_LOG_DEBUG | |
63 | # ifdef __WXDEBUG__ | |
64 | # define wxUSE_LOG_DEBUG 1 | |
65 | # else // !__WXDEBUG__ | |
66 | # define wxUSE_LOG_DEBUG 0 | |
67 | # endif | |
68 | #endif | |
69 | ||
70 | // ---------------------------------------------------------------------------- | |
71 | // forward declarations | |
72 | // ---------------------------------------------------------------------------- | |
73 | ||
74 | #if wxUSE_GUI | |
75 | class WXDLLIMPEXP_FWD_CORE wxTextCtrl; | |
76 | class WXDLLIMPEXP_FWD_CORE wxLogFrame; | |
77 | class WXDLLIMPEXP_FWD_CORE wxFrame; | |
78 | class WXDLLIMPEXP_FWD_CORE wxWindow; | |
79 | #endif // wxUSE_GUI | |
80 | ||
81 | // ---------------------------------------------------------------------------- | |
82 | // constants | |
83 | // ---------------------------------------------------------------------------- | |
84 | ||
85 | // different standard log levels (you may also define your own) | |
86 | enum wxLogLevelValues | |
87 | { | |
88 | wxLOG_FatalError, // program can't continue, abort immediately | |
89 | wxLOG_Error, // a serious error, user must be informed about it | |
90 | wxLOG_Warning, // user is normally informed about it but may be ignored | |
91 | wxLOG_Message, // normal message (i.e. normal output of a non GUI app) | |
92 | wxLOG_Status, // informational: might go to the status line of GUI app | |
93 | wxLOG_Info, // informational message (a.k.a. 'Verbose') | |
94 | wxLOG_Debug, // never shown to the user, disabled in release mode | |
95 | wxLOG_Trace, // trace messages are also only enabled in debug mode | |
96 | wxLOG_Progress, // used for progress indicator (not yet) | |
97 | wxLOG_User = 100, // user defined levels start here | |
98 | wxLOG_Max = 10000 | |
99 | }; | |
100 | ||
101 | // symbolic trace masks - wxLogTrace("foo", "some trace message...") will be | |
102 | // discarded unless the string "foo" has been added to the list of allowed | |
103 | // ones with AddTraceMask() | |
104 | ||
105 | #define wxTRACE_MemAlloc wxT("memalloc") // trace memory allocation (new/delete) | |
106 | #define wxTRACE_Messages wxT("messages") // trace window messages/X callbacks | |
107 | #define wxTRACE_ResAlloc wxT("resalloc") // trace GDI resource allocation | |
108 | #define wxTRACE_RefCount wxT("refcount") // trace various ref counting operations | |
109 | ||
110 | #ifdef __WXMSW__ | |
111 | #define wxTRACE_OleCalls wxT("ole") // OLE interface calls | |
112 | #endif | |
113 | ||
114 | #include "wx/iosfwrap.h" | |
115 | ||
116 | // ---------------------------------------------------------------------------- | |
117 | // derive from this class to redirect (or suppress, or ...) log messages | |
118 | // normally, only a single instance of this class exists but it's not enforced | |
119 | // ---------------------------------------------------------------------------- | |
120 | ||
121 | class WXDLLIMPEXP_BASE wxLog | |
122 | { | |
123 | public: | |
124 | // ctor | |
125 | wxLog(){} | |
126 | ||
127 | // these functions allow to completely disable all log messages | |
128 | ||
129 | // is logging disabled now? | |
130 | static bool IsEnabled() { return ms_doLog; } | |
131 | ||
132 | // change the flag state, return the previous one | |
133 | static bool EnableLogging(bool doIt = true) | |
134 | { bool doLogOld = ms_doLog; ms_doLog = doIt; return doLogOld; } | |
135 | ||
136 | // static sink function - see DoLog() for function to overload in the | |
137 | // derived classes | |
138 | static void OnLog(wxLogLevel level, const wxString& szString, time_t t); | |
139 | ||
140 | // message buffering | |
141 | ||
142 | // flush shows all messages if they're not logged immediately (FILE | |
143 | // and iostream logs don't need it, but wxGuiLog does to avoid showing | |
144 | // 17 modal dialogs one after another) | |
145 | virtual void Flush(); | |
146 | ||
147 | // flush the active target if any | |
148 | static void FlushActive() | |
149 | { | |
150 | if ( !ms_suspendCount ) | |
151 | { | |
152 | wxLog *log = GetActiveTarget(); | |
153 | if ( log ) | |
154 | log->Flush(); | |
155 | } | |
156 | } | |
157 | ||
158 | // only one sink is active at each moment | |
159 | // get current log target, will call wxApp::CreateLogTarget() to | |
160 | // create one if none exists | |
161 | static wxLog *GetActiveTarget(); | |
162 | ||
163 | // change log target, pLogger may be NULL | |
164 | static wxLog *SetActiveTarget(wxLog *pLogger); | |
165 | ||
166 | // suspend the message flushing of the main target until the next call | |
167 | // to Resume() - this is mainly for internal use (to prevent wxYield() | |
168 | // from flashing the messages) | |
169 | static void Suspend() { ms_suspendCount++; } | |
170 | ||
171 | // must be called for each Suspend()! | |
172 | static void Resume() { ms_suspendCount--; } | |
173 | ||
174 | // functions controlling the default wxLog behaviour | |
175 | // verbose mode is activated by standard command-line '-verbose' | |
176 | // option | |
177 | static void SetVerbose(bool bVerbose = true) { ms_bVerbose = bVerbose; } | |
178 | ||
179 | // Set log level. Log messages with level > logLevel will not be logged. | |
180 | static void SetLogLevel(wxLogLevel logLevel) { ms_logLevel = logLevel; } | |
181 | ||
182 | // should GetActiveTarget() try to create a new log object if the | |
183 | // current is NULL? | |
184 | static void DontCreateOnDemand(); | |
185 | ||
186 | // Make GetActiveTarget() create a new log object again. | |
187 | static void DoCreateOnDemand(); | |
188 | ||
189 | // log the count of repeating messages instead of logging the messages | |
190 | // multiple times | |
191 | static void SetRepetitionCounting(bool bRepetCounting = true) | |
192 | { ms_bRepetCounting = bRepetCounting; } | |
193 | ||
194 | // gets duplicate counting status | |
195 | static bool GetRepetitionCounting() { return ms_bRepetCounting; } | |
196 | ||
197 | // trace mask (see wxTraceXXX constants for details) | |
198 | static void SetTraceMask(wxTraceMask ulMask) { ms_ulTraceMask = ulMask; } | |
199 | ||
200 | // add string trace mask | |
201 | static void AddTraceMask(const wxString& str) | |
202 | { ms_aTraceMasks.push_back(str); } | |
203 | ||
204 | // add string trace mask | |
205 | static void RemoveTraceMask(const wxString& str); | |
206 | ||
207 | // remove all string trace masks | |
208 | static void ClearTraceMasks(); | |
209 | ||
210 | // get string trace masks | |
211 | static const wxArrayString &GetTraceMasks() { return ms_aTraceMasks; } | |
212 | ||
213 | // sets the time stamp string format: this is used as strftime() format | |
214 | // string for the log targets which add time stamps to the messages; set | |
215 | // it to empty string to disable time stamping completely. | |
216 | static void SetTimestamp(const wxString& ts) { ms_timestamp = ts; } | |
217 | ||
218 | // disable time stamping of log messages | |
219 | static void DisableTimestamp() { SetTimestamp(wxEmptyString); } | |
220 | ||
221 | ||
222 | // accessors | |
223 | ||
224 | // gets the verbose status | |
225 | static bool GetVerbose() { return ms_bVerbose; } | |
226 | ||
227 | // get trace mask | |
228 | static wxTraceMask GetTraceMask() { return ms_ulTraceMask; } | |
229 | ||
230 | // is this trace mask in the list? | |
231 | static bool IsAllowedTraceMask(const wxString& mask); | |
232 | ||
233 | // return the current loglevel limit | |
234 | static wxLogLevel GetLogLevel() { return ms_logLevel; } | |
235 | ||
236 | // get the current timestamp format string (may be NULL) | |
237 | static const wxString& GetTimestamp() { return ms_timestamp; } | |
238 | ||
239 | ||
240 | // helpers | |
241 | ||
242 | // put the time stamp into the string if ms_timestamp != NULL (don't | |
243 | // change it otherwise) | |
244 | static void TimeStamp(wxString *str); | |
245 | ||
246 | // make dtor virtual for all derived classes | |
247 | virtual ~wxLog(); | |
248 | ||
249 | ||
250 | // this method exists for backwards compatibility only, don't use | |
251 | bool HasPendingMessages() const { return true; } | |
252 | ||
253 | #if WXWIN_COMPATIBILITY_2_6 | |
254 | // this function doesn't do anything any more, don't call it | |
255 | wxDEPRECATED( static wxChar *SetLogBuffer(wxChar *buf, size_t size = 0) ); | |
256 | #endif | |
257 | ||
258 | protected: | |
259 | // the logging functions that can be overriden | |
260 | ||
261 | // default DoLog() prepends the time stamp and a prefix corresponding | |
262 | // to the message to szString and then passes it to DoLogString() | |
263 | virtual void DoLog(wxLogLevel level, const wxString& szString, time_t t); | |
264 | #if WXWIN_COMPATIBILITY_2_8 | |
265 | // these shouldn't be used by new code | |
266 | wxDEPRECATED_BUT_USED_INTERNALLY( | |
267 | virtual void DoLog(wxLogLevel level, const char *szString, time_t t) | |
268 | ); | |
269 | ||
270 | wxDEPRECATED_BUT_USED_INTERNALLY( | |
271 | virtual void DoLog(wxLogLevel level, const wchar_t *wzString, time_t t) | |
272 | ); | |
273 | #endif // WXWIN_COMPATIBILITY_2_8 | |
274 | ||
275 | void LogString(const wxString& szString, time_t t) | |
276 | { DoLogString(szString, t); } | |
277 | ||
278 | // default DoLogString does nothing but is not pure virtual because if | |
279 | // you override DoLog() you might not need it at all | |
280 | virtual void DoLogString(const wxString& szString, time_t t); | |
281 | #if WXWIN_COMPATIBILITY_2_8 | |
282 | // these shouldn't be used by new code | |
283 | virtual void DoLogString(const char *WXUNUSED(szString), | |
284 | time_t WXUNUSED(t)) {} | |
285 | virtual void DoLogString(const wchar_t *WXUNUSED(szString), | |
286 | time_t WXUNUSED(t)) {} | |
287 | #endif // WXWIN_COMPATIBILITY_2_8 | |
288 | ||
289 | // this macro should be used in the derived classes to avoid warnings about | |
290 | // hiding the other DoLog() overloads when overriding DoLog(wxString) -- | |
291 | // but don't use it with MSVC which doesn't give this warning but does give | |
292 | // warning when a deprecated function is overridden | |
293 | #if WXWIN_COMPATIBILITY_2_8 && !defined(__VISUALC__) | |
294 | #define wxSUPPRESS_DOLOG_HIDE_WARNING() \ | |
295 | virtual void DoLog(wxLogLevel, const char *, time_t) { } \ | |
296 | virtual void DoLog(wxLogLevel, const wchar_t *, time_t) { } | |
297 | ||
298 | #define wxSUPPRESS_DOLOGSTRING_HIDE_WARNING() \ | |
299 | virtual void DoLogString(const char *, time_t) { } \ | |
300 | virtual void DoLogString(const wchar_t *, time_t) { } | |
301 | #else | |
302 | #define wxSUPPRESS_DOLOG_HIDE_WARNING() | |
303 | #define wxSUPPRESS_DOLOGSTRING_HIDE_WARNING() | |
304 | #endif | |
305 | ||
306 | // log a message indicating the number of times the previous message was | |
307 | // repeated if ms_prevCounter > 0, does nothing otherwise; return the old | |
308 | // value of ms_prevCounter | |
309 | static unsigned LogLastRepetitionCountIfNeeded(); | |
310 | ||
311 | private: | |
312 | // static variables | |
313 | // ---------------- | |
314 | ||
315 | // if true, don't log the same message multiple times, only log it once | |
316 | // with the number of times it was repeated | |
317 | static bool ms_bRepetCounting; | |
318 | ||
319 | wxCRIT_SECT_DECLARE(ms_prevCS); // protects the ms_prev values below | |
320 | static wxString ms_prevString; // previous message that was logged | |
321 | static unsigned ms_prevCounter; // how many times it was repeated | |
322 | static time_t ms_prevTimeStamp;// timestamp of the previous message | |
323 | static wxLogLevel ms_prevLevel; // level of the previous message | |
324 | ||
325 | static wxLog *ms_pLogger; // currently active log sink | |
326 | static bool ms_doLog; // false => all logging disabled | |
327 | static bool ms_bAutoCreate; // create new log targets on demand? | |
328 | static bool ms_bVerbose; // false => ignore LogInfo messages | |
329 | ||
330 | static wxLogLevel ms_logLevel; // limit logging to levels <= ms_logLevel | |
331 | ||
332 | static size_t ms_suspendCount; // if positive, logs are not flushed | |
333 | ||
334 | // format string for strftime(), if NULL, time stamping log messages is | |
335 | // disabled | |
336 | static wxString ms_timestamp; | |
337 | ||
338 | static wxTraceMask ms_ulTraceMask; // controls wxLogTrace behaviour | |
339 | static wxArrayString ms_aTraceMasks; // more powerful filter for wxLogTrace | |
340 | }; | |
341 | ||
342 | // ---------------------------------------------------------------------------- | |
343 | // "trivial" derivations of wxLog | |
344 | // ---------------------------------------------------------------------------- | |
345 | ||
346 | // log everything to a buffer | |
347 | class WXDLLIMPEXP_BASE wxLogBuffer : public wxLog | |
348 | { | |
349 | public: | |
350 | wxLogBuffer() { } | |
351 | ||
352 | // get the string contents with all messages logged | |
353 | const wxString& GetBuffer() const { return m_str; } | |
354 | ||
355 | // show the buffer contents to the user in the best possible way (this uses | |
356 | // wxMessageOutputMessageBox) and clear it | |
357 | virtual void Flush(); | |
358 | ||
359 | protected: | |
360 | virtual void DoLog(wxLogLevel level, const wxString& szString, time_t t); | |
361 | virtual void DoLogString(const wxString& szString, time_t t); | |
362 | ||
363 | wxSUPPRESS_DOLOG_HIDE_WARNING() | |
364 | wxSUPPRESS_DOLOGSTRING_HIDE_WARNING() | |
365 | ||
366 | private: | |
367 | wxString m_str; | |
368 | ||
369 | DECLARE_NO_COPY_CLASS(wxLogBuffer) | |
370 | }; | |
371 | ||
372 | ||
373 | // log everything to a "FILE *", stderr by default | |
374 | class WXDLLIMPEXP_BASE wxLogStderr : public wxLog | |
375 | { | |
376 | public: | |
377 | // redirect log output to a FILE | |
378 | wxLogStderr(FILE *fp = (FILE *) NULL); | |
379 | ||
380 | protected: | |
381 | // implement sink function | |
382 | virtual void DoLogString(const wxString& szString, time_t t); | |
383 | ||
384 | wxSUPPRESS_DOLOGSTRING_HIDE_WARNING() | |
385 | ||
386 | FILE *m_fp; | |
387 | ||
388 | DECLARE_NO_COPY_CLASS(wxLogStderr) | |
389 | }; | |
390 | ||
391 | #if wxUSE_STD_IOSTREAM | |
392 | ||
393 | // log everything to an "ostream", cerr by default | |
394 | class WXDLLIMPEXP_BASE wxLogStream : public wxLog | |
395 | { | |
396 | public: | |
397 | // redirect log output to an ostream | |
398 | wxLogStream(wxSTD ostream *ostr = (wxSTD ostream *) NULL); | |
399 | ||
400 | protected: | |
401 | // implement sink function | |
402 | virtual void DoLogString(const wxString& szString, time_t t); | |
403 | ||
404 | wxSUPPRESS_DOLOGSTRING_HIDE_WARNING() | |
405 | ||
406 | // using ptr here to avoid including <iostream.h> from this file | |
407 | wxSTD ostream *m_ostr; | |
408 | }; | |
409 | ||
410 | #endif // wxUSE_STD_IOSTREAM | |
411 | ||
412 | // ---------------------------------------------------------------------------- | |
413 | // /dev/null log target: suppress logging until this object goes out of scope | |
414 | // ---------------------------------------------------------------------------- | |
415 | ||
416 | // example of usage: | |
417 | /* | |
418 | void Foo() | |
419 | { | |
420 | wxFile file; | |
421 | ||
422 | // wxFile.Open() normally complains if file can't be opened, we don't | |
423 | // want it | |
424 | wxLogNull logNo; | |
425 | ||
426 | if ( !file.Open("bar") ) | |
427 | ... process error ourselves ... | |
428 | ||
429 | // ~wxLogNull called, old log sink restored | |
430 | } | |
431 | */ | |
432 | class WXDLLIMPEXP_BASE wxLogNull | |
433 | { | |
434 | public: | |
435 | wxLogNull() : m_flagOld(wxLog::EnableLogging(false)) { } | |
436 | ~wxLogNull() { (void)wxLog::EnableLogging(m_flagOld); } | |
437 | ||
438 | private: | |
439 | bool m_flagOld; // the previous value of the wxLog::ms_doLog | |
440 | }; | |
441 | ||
442 | // ---------------------------------------------------------------------------- | |
443 | // chaining log target: installs itself as a log target and passes all | |
444 | // messages to the real log target given to it in the ctor but also forwards | |
445 | // them to the previously active one | |
446 | // | |
447 | // note that you don't have to call SetActiveTarget() with this class, it | |
448 | // does it itself in its ctor | |
449 | // ---------------------------------------------------------------------------- | |
450 | ||
451 | class WXDLLIMPEXP_BASE wxLogChain : public wxLog | |
452 | { | |
453 | public: | |
454 | wxLogChain(wxLog *logger); | |
455 | virtual ~wxLogChain(); | |
456 | ||
457 | // change the new log target | |
458 | void SetLog(wxLog *logger); | |
459 | ||
460 | // this can be used to temporarily disable (and then reenable) passing | |
461 | // messages to the old logger (by default we do pass them) | |
462 | void PassMessages(bool bDoPass) { m_bPassMessages = bDoPass; } | |
463 | ||
464 | // are we passing the messages to the previous log target? | |
465 | bool IsPassingMessages() const { return m_bPassMessages; } | |
466 | ||
467 | // return the previous log target (may be NULL) | |
468 | wxLog *GetOldLog() const { return m_logOld; } | |
469 | ||
470 | // override base class version to flush the old logger as well | |
471 | virtual void Flush(); | |
472 | ||
473 | // call to avoid destroying the old log target | |
474 | void DetachOldLog() { m_logOld = NULL; } | |
475 | ||
476 | protected: | |
477 | // pass the chain to the old logger if needed | |
478 | virtual void DoLog(wxLogLevel level, const wxString& szString, time_t t); | |
479 | ||
480 | wxSUPPRESS_DOLOG_HIDE_WARNING() | |
481 | ||
482 | private: | |
483 | // the current log target | |
484 | wxLog *m_logNew; | |
485 | ||
486 | // the previous log target | |
487 | wxLog *m_logOld; | |
488 | ||
489 | // do we pass the messages to the old logger? | |
490 | bool m_bPassMessages; | |
491 | ||
492 | DECLARE_NO_COPY_CLASS(wxLogChain) | |
493 | }; | |
494 | ||
495 | // a chain log target which uses itself as the new logger | |
496 | ||
497 | #define wxLogPassThrough wxLogInterposer | |
498 | ||
499 | class WXDLLIMPEXP_BASE wxLogInterposer : public wxLogChain | |
500 | { | |
501 | public: | |
502 | wxLogInterposer(); | |
503 | ||
504 | private: | |
505 | DECLARE_NO_COPY_CLASS(wxLogInterposer) | |
506 | }; | |
507 | ||
508 | // a temporary interposer which doesn't destroy the old log target | |
509 | // (calls DetachOldLog) | |
510 | ||
511 | class WXDLLIMPEXP_BASE wxLogInterposerTemp : public wxLogChain | |
512 | { | |
513 | public: | |
514 | wxLogInterposerTemp(); | |
515 | ||
516 | private: | |
517 | DECLARE_NO_COPY_CLASS(wxLogInterposerTemp) | |
518 | }; | |
519 | ||
520 | #if wxUSE_GUI | |
521 | // include GUI log targets: | |
522 | #include "wx/generic/logg.h" | |
523 | #endif // wxUSE_GUI | |
524 | ||
525 | // ============================================================================ | |
526 | // global functions | |
527 | // ============================================================================ | |
528 | ||
529 | // ---------------------------------------------------------------------------- | |
530 | // Log functions should be used by application instead of stdio, iostream &c | |
531 | // for log messages for easy redirection | |
532 | // ---------------------------------------------------------------------------- | |
533 | ||
534 | // ---------------------------------------------------------------------------- | |
535 | // get error code/error message from system in a portable way | |
536 | // ---------------------------------------------------------------------------- | |
537 | ||
538 | // return the last system error code | |
539 | WXDLLIMPEXP_BASE unsigned long wxSysErrorCode(); | |
540 | ||
541 | // return the error message for given (or last if 0) error code | |
542 | WXDLLIMPEXP_BASE const wxChar* wxSysErrorMsg(unsigned long nErrCode = 0); | |
543 | ||
544 | // ---------------------------------------------------------------------------- | |
545 | // define wxLog<level> | |
546 | // ---------------------------------------------------------------------------- | |
547 | ||
548 | #define DECLARE_LOG_FUNCTION(level) \ | |
549 | extern void WXDLLIMPEXP_BASE \ | |
550 | wxDoLog##level##Wchar(const wxChar *format, ...); \ | |
551 | extern void WXDLLIMPEXP_BASE \ | |
552 | wxDoLog##level##Utf8(const char *format, ...); \ | |
553 | WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \ | |
554 | 1, (const wxFormatString&), \ | |
555 | wxDoLog##level##Wchar, wxDoLog##level##Utf8) \ | |
556 | DECLARE_LOG_FUNCTION_WATCOM(level) \ | |
557 | extern void WXDLLIMPEXP_BASE wxVLog##level(const wxString& format, \ | |
558 | va_list argptr) | |
559 | ||
560 | #ifdef __WATCOMC__ | |
561 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351; | |
562 | // can't use WX_WATCOM_ONLY_CODE here because the macro would expand to | |
563 | // something too big for Borland C++ to handle | |
564 | #define DECLARE_LOG_FUNCTION_WATCOM(level) \ | |
565 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
566 | 1, (const wxString&), \ | |
567 | (wxFormatString(f1))) \ | |
568 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
569 | 1, (const wxCStrData&), \ | |
570 | (wxFormatString(f1))) \ | |
571 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
572 | 1, (const char*), \ | |
573 | (wxFormatString(f1))) \ | |
574 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
575 | 1, (const wchar_t*), \ | |
576 | (wxFormatString(f1))) | |
577 | #else | |
578 | #define DECLARE_LOG_FUNCTION_WATCOM(level) | |
579 | #endif | |
580 | ||
581 | ||
582 | #define DECLARE_LOG_FUNCTION2_EXP(level, argclass, arg, expdecl) \ | |
583 | extern void expdecl wxDoLog##level##Wchar(argclass arg, \ | |
584 | const wxChar *format, ...); \ | |
585 | extern void expdecl wxDoLog##level##Utf8(argclass arg, \ | |
586 | const char *format, ...); \ | |
587 | WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \ | |
588 | 2, (argclass, const wxFormatString&), \ | |
589 | wxDoLog##level##Wchar, wxDoLog##level##Utf8) \ | |
590 | DECLARE_LOG_FUNCTION2_EXP_WATCOM(level, argclass, arg, expdecl) \ | |
591 | extern void expdecl wxVLog##level(argclass arg, \ | |
592 | const wxString& format, \ | |
593 | va_list argptr) | |
594 | ||
595 | #ifdef __WATCOMC__ | |
596 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351; | |
597 | // can't use WX_WATCOM_ONLY_CODE here because the macro would expand to | |
598 | // something too big for Borland C++ to handle | |
599 | #define DECLARE_LOG_FUNCTION2_EXP_WATCOM(level, argclass, arg, expdecl) \ | |
600 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
601 | 2, (argclass, const wxString&), \ | |
602 | (f1, wxFormatString(f2))) \ | |
603 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
604 | 2, (argclass, const wxCStrData&), \ | |
605 | (f1, wxFormatString(f2))) \ | |
606 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
607 | 2, (argclass, const char*), \ | |
608 | (f1, wxFormatString(f2))) \ | |
609 | WX_VARARG_WATCOM_WORKAROUND(void, wxLog##level, \ | |
610 | 2, (argclass, const wchar_t*), \ | |
611 | (f1, wxFormatString(f2))) | |
612 | #else | |
613 | #define DECLARE_LOG_FUNCTION2_EXP_WATCOM(level, argclass, arg, expdecl) | |
614 | #endif | |
615 | ||
616 | ||
617 | #else // !wxUSE_LOG | |
618 | ||
619 | #ifdef __WATCOMC__ | |
620 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
621 | #define WX_WATCOM_ONLY_CODE( x ) x | |
622 | #else | |
623 | #define WX_WATCOM_ONLY_CODE( x ) | |
624 | #endif | |
625 | ||
626 | #if defined(__WATCOMC__) || defined(__MINGW32__) | |
627 | // Mingw has similar problem with wxLogSysError: | |
628 | #define WX_WATCOM_OR_MINGW_ONLY_CODE( x ) x | |
629 | #else | |
630 | #define WX_WATCOM_OR_MINGW_ONLY_CODE( x ) | |
631 | #endif | |
632 | ||
633 | // log functions do nothing at all | |
634 | #define DECLARE_LOG_FUNCTION(level) \ | |
635 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxString&)) \ | |
636 | WX_WATCOM_ONLY_CODE( \ | |
637 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const char*)) \ | |
638 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wchar_t*)) \ | |
639 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 1, (const wxCStrData&)) \ | |
640 | ) \ | |
641 | inline void wxVLog##level(const wxString& WXUNUSED(format), \ | |
642 | va_list WXUNUSED(argptr)) { } \ | |
643 | ||
644 | #define DECLARE_LOG_FUNCTION2_EXP(level, argclass, arg, expdecl) \ | |
645 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxString&)) \ | |
646 | WX_WATCOM_OR_MINGW_ONLY_CODE( \ | |
647 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const char*)) \ | |
648 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wchar_t*)) \ | |
649 | WX_DEFINE_VARARG_FUNC_NOP(wxLog##level, 2, (argclass, const wxCStrData&)) \ | |
650 | ) \ | |
651 | inline void wxVLog##level(argclass WXUNUSED(arg), \ | |
652 | const wxString& WXUNUSED(format), \ | |
653 | va_list WXUNUSED(argptr)) {} | |
654 | ||
655 | // Empty Class to fake wxLogNull | |
656 | class WXDLLIMPEXP_BASE wxLogNull | |
657 | { | |
658 | public: | |
659 | wxLogNull() { } | |
660 | }; | |
661 | ||
662 | // Dummy macros to replace some functions. | |
663 | #define wxSysErrorCode() (unsigned long)0 | |
664 | #define wxSysErrorMsg( X ) (const wxChar*)NULL | |
665 | ||
666 | // Fake symbolic trace masks... for those that are used frequently | |
667 | #define wxTRACE_OleCalls wxEmptyString // OLE interface calls | |
668 | ||
669 | #endif // wxUSE_LOG/!wxUSE_LOG | |
670 | ||
671 | #define DECLARE_LOG_FUNCTION2(level, argclass, arg) \ | |
672 | DECLARE_LOG_FUNCTION2_EXP(level, argclass, arg, WXDLLIMPEXP_BASE) | |
673 | ||
674 | // VC6 produces a warning if we a macro expanding to nothing to | |
675 | // DECLARE_LOG_FUNCTION2: | |
676 | #if defined(__VISUALC__) && __VISUALC__ < 1300 | |
677 | // "not enough actual parameters for macro 'DECLARE_LOG_FUNCTION2_EXP'" | |
678 | #pragma warning(disable:4003) | |
679 | #endif | |
680 | ||
681 | // a generic function for all levels (level is passes as parameter) | |
682 | DECLARE_LOG_FUNCTION2(Generic, wxLogLevel, level); | |
683 | ||
684 | // one function per each level | |
685 | DECLARE_LOG_FUNCTION(FatalError); | |
686 | DECLARE_LOG_FUNCTION(Error); | |
687 | DECLARE_LOG_FUNCTION(Warning); | |
688 | DECLARE_LOG_FUNCTION(Message); | |
689 | DECLARE_LOG_FUNCTION(Info); | |
690 | DECLARE_LOG_FUNCTION(Verbose); | |
691 | ||
692 | // this function sends the log message to the status line of the top level | |
693 | // application frame, if any | |
694 | DECLARE_LOG_FUNCTION(Status); | |
695 | ||
696 | #if wxUSE_GUI | |
697 | // this one is the same as previous except that it allows to explicitly | |
698 | class WXDLLIMPEXP_FWD_CORE wxFrame; | |
699 | // specify the frame to which the output should go | |
700 | DECLARE_LOG_FUNCTION2_EXP(Status, wxFrame *, pFrame, WXDLLIMPEXP_CORE); | |
701 | #endif // wxUSE_GUI | |
702 | ||
703 | // additional one: as wxLogError, but also logs last system call error code | |
704 | // and the corresponding error message if available | |
705 | DECLARE_LOG_FUNCTION(SysError); | |
706 | ||
707 | // and another one which also takes the error code (for those broken APIs | |
708 | // that don't set the errno (like registry APIs in Win32)) | |
709 | DECLARE_LOG_FUNCTION2(SysError, long, lErrCode); | |
710 | #ifdef __WATCOMC__ | |
711 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
712 | DECLARE_LOG_FUNCTION2(SysError, unsigned long, lErrCode); | |
713 | #endif | |
714 | ||
715 | // debug functions do nothing in release mode | |
716 | #if wxUSE_LOG && wxUSE_LOG_DEBUG | |
717 | DECLARE_LOG_FUNCTION(Debug); | |
718 | ||
719 | // there is no more unconditional LogTrace: it is not different from | |
720 | // LogDebug and it creates overload ambiguities | |
721 | //DECLARE_LOG_FUNCTION(Trace); | |
722 | ||
723 | // this version only logs the message if the mask had been added to the | |
724 | // list of masks with AddTraceMask() | |
725 | DECLARE_LOG_FUNCTION2(Trace, const wxString&, mask); | |
726 | #ifdef __WATCOMC__ | |
727 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
728 | DECLARE_LOG_FUNCTION2(Trace, const char*, mask); | |
729 | DECLARE_LOG_FUNCTION2(Trace, const wchar_t*, mask); | |
730 | #endif | |
731 | ||
732 | // and this one does nothing if all of level bits are not set in | |
733 | // wxLog::GetActive()->GetTraceMask() -- it's deprecated in favour of | |
734 | // string identifiers | |
735 | DECLARE_LOG_FUNCTION2(Trace, wxTraceMask, mask); | |
736 | #ifdef __WATCOMC__ | |
737 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
738 | DECLARE_LOG_FUNCTION2(Trace, int, mask); | |
739 | #endif | |
740 | #else //!debug || !wxUSE_LOG | |
741 | // these functions do nothing in release builds, but don't define them as | |
742 | // nothing as it could result in different code structure in debug and | |
743 | // release and this could result in trouble when these macros are used | |
744 | // inside if/else | |
745 | // | |
746 | // note that making wxVLogDebug/Trace() themselves (empty inline) functions | |
747 | // is a bad idea as some compilers are stupid enough to not inline even | |
748 | // empty functions if their parameters are complicated enough, but by | |
749 | // defining them as an empty inline function we ensure that even dumbest | |
750 | // compilers optimise them away | |
751 | inline void wxLogNop() { } | |
752 | ||
753 | #define wxVLogDebug(fmt, valist) wxLogNop() | |
754 | #define wxVLogTrace(mask, fmt, valist) wxLogNop() | |
755 | ||
756 | #ifdef HAVE_VARIADIC_MACROS | |
757 | // unlike the inline functions below, this completely removes the | |
758 | // wxLogXXX calls from the object file: | |
759 | #define wxLogDebug(fmt, ...) wxLogNop() | |
760 | #define wxLogTrace(mask, fmt, ...) wxLogNop() | |
761 | #else // !HAVE_VARIADIC_MACROS | |
762 | //inline void wxLogDebug(const wxString& fmt, ...) {} | |
763 | WX_DEFINE_VARARG_FUNC_NOP(wxLogDebug, 1, (const wxString&)) | |
764 | //inline void wxLogTrace(wxTraceMask, const wxString& fmt, ...) {} | |
765 | //inline void wxLogTrace(const wxString&, const wxString& fmt, ...) {} | |
766 | WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (wxTraceMask, const wxString&)) | |
767 | WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wxString&, const wxString&)) | |
768 | #ifdef __WATCOMC__ | |
769 | // workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351 | |
770 | WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const char*, const char*)) | |
771 | WX_DEFINE_VARARG_FUNC_NOP(wxLogTrace, 2, (const wchar_t*, const wchar_t*)) | |
772 | #endif | |
773 | #endif // HAVE_VARIADIC_MACROS/!HAVE_VARIADIC_MACROS | |
774 | #endif // debug/!debug | |
775 | ||
776 | #if defined(__VISUALC__) && __VISUALC__ < 1300 | |
777 | #pragma warning(default:4003) | |
778 | #endif | |
779 | ||
780 | // wxLogFatalError helper: show the (fatal) error to the user in a safe way, | |
781 | // i.e. without using wxMessageBox() for example because it could crash | |
782 | void WXDLLIMPEXP_BASE | |
783 | wxSafeShowMessage(const wxString& title, const wxString& text); | |
784 | ||
785 | // ---------------------------------------------------------------------------- | |
786 | // debug only logging functions: use them with API name and error code | |
787 | // ---------------------------------------------------------------------------- | |
788 | ||
789 | #ifdef __WXDEBUG__ | |
790 | // make life easier for people using VC++ IDE: clicking on the message | |
791 | // will take us immediately to the place of the failed API | |
792 | #ifdef __VISUALC__ | |
793 | #define wxLogApiError(api, rc) \ | |
794 | wxLogDebug(wxT("%s(%d): '%s' failed with error 0x%08lx (%s)."), \ | |
795 | __FILE__, __LINE__, api, \ | |
796 | (long)rc, wxSysErrorMsg(rc)) | |
797 | #else // !VC++ | |
798 | #define wxLogApiError(api, rc) \ | |
799 | wxLogDebug(wxT("In file %s at line %d: '%s' failed with ") \ | |
800 | wxT("error 0x%08lx (%s)."), \ | |
801 | __FILE__, __LINE__, api, \ | |
802 | (long)rc, wxSysErrorMsg(rc)) | |
803 | #endif // VC++/!VC++ | |
804 | ||
805 | #define wxLogLastError(api) wxLogApiError(api, wxSysErrorCode()) | |
806 | ||
807 | #else //!debug | |
808 | #define wxLogApiError(api, err) wxLogNop() | |
809 | #define wxLogLastError(api) wxLogNop() | |
810 | #endif //debug/!debug | |
811 | ||
812 | // wxCocoa has additiional trace masks | |
813 | #if defined(__WXCOCOA__) | |
814 | #include "wx/cocoa/log.h" | |
815 | #endif | |
816 | ||
817 | #ifdef WX_WATCOM_ONLY_CODE | |
818 | #undef WX_WATCOM_ONLY_CODE | |
819 | #endif | |
820 | ||
821 | #endif // _WX_LOG_H_ | |
822 |