Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first round of debug/release merge: introduce wxDEBUG_LEVEL, for now defined as 1 if __WXDEBUG__ is defined, i.e. no real changes; don't use __WXDEBUG__ in the headers to keep debug and release builds ABI-compatible; add functions to customize or disable asserts handling

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@59711 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2009-03-21 23:36:37 +00:00
parent b822bdc032
commit 657a8a3598
43 changed files with 659 additions and 568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/wx/app.h
View File

@@ -335,7 +335,6 @@ public:
// debugging support
// -----------------
#ifdef __WXDEBUG__
// this function is called when an assert failure occurs, the base class
// version does the normal processing (i.e. shows the usual assert failure
// dialog box)
@@ -355,7 +354,6 @@ public:
int line,
const wxChar *cond,
const wxChar *msg);
#endif // __WXDEBUG__
// check that the wxBuildOptions object (constructed in the application
// itself, usually the one from IMPLEMENT_APP() macro) matches the build

8
include/wx/apptrait.h
View File

@@ -87,7 +87,6 @@ public:
// functions abstracting differences between GUI and console modes
// ------------------------------------------------------------------------
#ifdef __WXDEBUG__
// show the assert dialog with the specified message in GUI or just print
// the string to stderr in console mode
//
@@ -96,7 +95,6 @@ public:
//
// return true to suppress subsequent asserts, false to continue as before
virtual bool ShowAssertDialog(const wxString& msg) = 0;
#endif // __WXDEBUG__
// return true if fprintf(stderr) goes somewhere, false otherwise
virtual bool HasStderr() = 0;
@@ -177,7 +175,7 @@ public:
protected:
#if wxUSE_STACKWALKER && defined( __WXDEBUG__ )
#if wxUSE_STACKWALKER
// utility function: returns the stack frame as a plain wxString
virtual wxString GetAssertStackTrace();
#endif
@@ -232,9 +230,7 @@ public:
#endif // wxUSE_FONTMAP
virtual wxRendererNative *CreateRenderer();
#ifdef __WXDEBUG__
virtual bool ShowAssertDialog(const wxString& msg);
#endif // __WXDEBUG__
virtual bool HasStderr();
virtual void ScheduleForDestroy(wxObject *object);
@@ -273,9 +269,7 @@ public:
#endif // wxUSE_FONTMAP
virtual wxRendererNative *CreateRenderer();
#ifdef __WXDEBUG__
virtual bool ShowAssertDialog(const wxString& msg);
#endif // __WXDEBUG__
virtual bool HasStderr();
virtual void ScheduleForDestroy(wxObject *object);

9
include/wx/cocoa/app.h
View File

@@ -67,17 +67,8 @@ public:
virtual bool OnInit();
virtual bool OnInitGui();
#ifdef __WXDEBUG__
virtual void OnAssert(const wxChar *file, int line, const wxChar *cond, const wxChar *msg);
bool IsInAssert() const { return m_isInAssert; }
#endif // __WXDEBUG__
// Set true _before_ initializing wx to force embedded mode (no app delegate, etc.)
static bool sm_isEmbedded;
private:
#ifdef __WXDEBUG__
bool m_isInAssert;
#endif // __WXDEBUG__
};
#endif // _WX_COCOA_APP_H_

4
include/wx/dataview.h
View File

@@ -81,10 +81,6 @@ public:
void* GetID() const { return m_id; }
operator const void* () const { return m_id; }
#ifdef __WXDEBUG__
void Print( const wxString &text ) const;
#endif
private:
void* m_id;
};

23
include/wx/dcbuffer.h
View File

@@ -216,9 +216,6 @@ private:
#define wxAutoBufferedPaintDCBase wxBufferedPaintDC
#endif
#ifdef __WXDEBUG__
class WXDLLIMPEXP_CORE wxAutoBufferedPaintDC : public wxAutoBufferedPaintDCBase
{
public:
@@ -226,30 +223,18 @@ public:
wxAutoBufferedPaintDC(wxWindow* win)
: wxAutoBufferedPaintDCBase(win)
{
TestWinStyle(win);
wxASSERT_MSG( win->GetBackgroundStyle() == wxBG_STYLE_CUSTOM,
"You need to call SetBackgroundStyle(wxBG_STYLE_CUSTOM) in ctor, "
"and also, if needed, paint the background in wxEVT_PAINT handler."
);
}
virtual ~wxAutoBufferedPaintDC() { }
private:
void TestWinStyle(wxWindow* win)
{
// Help the user to get the double-buffering working properly.
wxASSERT_MSG( win->GetBackgroundStyle() == wxBG_STYLE_CUSTOM,
wxT("In constructor, you need to call SetBackgroundStyle(wxBG_STYLE_CUSTOM), ")
wxT("and also, if needed, paint the background manually in the paint event handler."));
}
wxDECLARE_NO_COPY_CLASS(wxAutoBufferedPaintDC);
};
#else // !__WXDEBUG__
// In release builds, just use typedef
typedef wxAutoBufferedPaintDCBase wxAutoBufferedPaintDC;
#endif
// Check if the window is natively double buffered and will return a wxPaintDC

443
include/wx/debug.h
View File

@@ -20,10 +20,30 @@
#include "wx/chartype.h" // for __TFILE__ and wxChar
#include "wx/cpp.h" // for __WXFUNCTION__
class WXDLLIMPEXP_FWD_BASE wxString;
class WXDLLIMPEXP_FWD_BASE wxCStrData;
// ----------------------------------------------------------------------------
// Defines controlling the debugging macros
// ----------------------------------------------------------------------------
/*
wxWidgets can be built with several different levels of debug support
specified by the value of wxDEBUG_LEVEL constant:
0: No assertion macros at all, this should only be used when optimizing
for resource-constrained systems (typically embedded ones).
1: Default level, most of the assertions are enabled.
2: Maximal (at least for now): asserts which are "expensive"
(performance-wise) or only make sense for finding errors in wxWidgets
itself, as opposed to bugs in applications using it, are also enabled.
For compatibility reasons, currently wxDEBUG_LEVEL is defined if
__WXDEBUG__ is defined but in the near future (2.9.1) the role of the flags
will change and wxDEBUG_LEVEL will be the primary value with __WXDEBUG__
only used for compatibility.
*/
// if _DEBUG is defined (MS VC++ and others use it in debug builds), define
// __WXDEBUG__ too
#ifdef _DEBUG
@@ -46,175 +66,235 @@
#endif // !WXDEBUG
#endif // __WXDEBUG__
// temporarily define wxDEBUG_LEVEL as function of __WXDEBUG__
#if !defined(wxDEBUG_LEVEL)
#ifdef __WXDEBUG__
#define wxDEBUG_LEVEL 1
#else
#define wxDEBUG_LEVEL 0
#endif
#endif // !defined(wxDEBUG_LEVEL)
// ----------------------------------------------------------------------------
// Debugging macros
//
// All debugging macros rely on ASSERT() which in turn calls the user-defined
// OnAssert() function. To keep things simple, it's called even when the
// expression is true (i.e. everything is ok) and by default does nothing: just
// returns the same value back. But if you redefine it to do something more sexy
// (popping up a message box in your favourite GUI, sending you e-mail or
// whatever) it will affect all ASSERTs, FAILs and CHECKs in your code.
//
// Warning: if you don't like advice on programming style, don't read
// further! ;-)
//
// Extensive use of these macros is recommended! Remember that ASSERTs are
// disabled in final build (without __WXDEBUG__ defined), so they add strictly
// nothing to your program's code. On the other hand, CHECK macros do stay
// even in release builds, but in general are not much of a burden, while
// a judicious use of them might increase your program's stability.
// Handling assertion failures
// ----------------------------------------------------------------------------
// Macros which are completely disabled in 'release' mode
//
// NB: these functions are implemented in src/common/appcmn.cpp
#if defined(__WXDEBUG__)
/*
This function is called whenever one of debugging macros fails (i.e.
condition is false in an assertion). To customize its behaviour, override
wxApp::OnAssertFailure().
Parameters:
szFile and nLine - file name and line number of the ASSERT
szFunc - function name of the ASSERT, may be NULL (NB: ASCII)
szCond - text form of the condition which failed
szMsg - optional message explaining the reason
*/
/* this version is for compatibility with wx 2.8 Unicode build only: */
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
int nLine,
const char *szFunc,
const wxChar *szCond,
const wxChar *szMsg = NULL);
#if wxUSE_UNICODE
/* char versions are used by debugging macros; we have to provide
wxChar* szMsg version because it's common to use _T() in the macros
and finally, we can't use const wx(char)* szMsg = NULL, because that
would be ambiguous: */
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
int nLine,
const char *szFunc,
const char *szCond);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
int nLine,
const char *szFunc,
const char *szCond,
const char *szMsg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
int nLine,
const char *szFunc,
const char *szCond,
const wxChar *szMsg);
#endif /* wxUSE_UNICODE */
class WXDLLIMPEXP_FWD_BASE wxString;
class WXDLLIMPEXP_FWD_BASE wxCStrData;
/* these two work when szMsg passed to debug macro is a string,
we also have to provide wxCStrData overload to resolve ambiguity
which would otherwise arise from wxASSERT( s.c_str() ): */
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
int nLine,
const wxString& szFunc,
const wxString& szCond,
const wxString& szMsg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
int nLine,
const wxString& szFunc,
const wxString& szCond);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
int nLine,
const char *szFunc,
const char *szCond,
const wxCStrData& msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
int nLine,
const char *szFunc,
const char *szCond,
const wxString& szMsg);
// call this function to break into the debugger unconditionally (assuming
// the program is running under debugger, of course)
extern void WXDLLIMPEXP_BASE wxTrap();
// generic assert macro
#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
// assert with additional message explaining its cause
// Note: some compilers will give a warning (such as
// "possible unwanted ;") when using a ";" instead of the "{}".
#define wxASSERT_MSG(cond, msg) \
if ( cond ) \
{} \
else \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
// special form of assert: always triggers it (in debug mode)
#define wxFAIL wxFAIL_MSG((const char*)NULL)
// FAIL with some message
#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
// FAIL with some message and a condition
#define wxFAIL_COND_MSG(cond, msg) \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
// An assert helper used to avoid warning when testing constant expressions,
// i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about
// expression being always true, but not using
// wxASSERT( wxAssertIsEqual(sizeof(int), 4) )
//
// NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no
// longer be used.
extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
#else
#define wxTrap()
// nothing to do in release mode (hopefully at this moment there are
// no more bugs ;-)
#define wxASSERT(cond)
#define wxASSERT_MSG(cond, msg)
#define wxFAIL
#define wxFAIL_MSG(msg)
#define wxFAIL_COND_MSG(cond, msg)
#endif /* __WXDEBUG__ */
// Use of wxFalse instead of false suppresses compiler warnings about testing
// constant expression
extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#define wxAssertFailure wxFalse
// NB: the following macros also work in release mode!
/*
These macros must be used only in invalid situation: for example, an
invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
dereferencing it and causing core dump the function might try using
CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
Type for the function called in case of assert failure, see
wxSetAssertHandler().
*/
typedef void (*wxAssertHandler_t)(const wxString& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
#if wxDEBUG_LEVEL
// the global assert handler function, if it is NULL asserts don't check their
// conditions
extern WXDLLIMPEXP_DATA_BASE(wxAssertHandler_t) wxTheAssertHandler;
/*
Sets the function to be called in case of assertion failure.
The default assert handler forwards to wxApp::OnAssertFailure() whose
default behaviour is, in turn, to show the standard assertion failure
dialog if a wxApp object exists or shows the same dialog itself directly
otherwise.
While usually it is enough -- and more convenient -- to just override
OnAssertFailure(), to handle all assertion failures, including those
occurring even before wxApp object creation of after its destruction you
need to provide your assertion handler function.
This function also provides a simple way to disable all asserts: simply
pass NULL pointer to it. Doing this will result in not even evaluating
assert conditions at all, avoiding almost all run-time cost of asserts.
Notice that this function is not MT-safe, so you should call it before
starting any other threads.
The return value of this function is the previous assertion handler. It can
be called after any pre-processing by your handler and can also be restored
later if you uninstall your handler.
*/
inline wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t handler)
{
const wxAssertHandler_t old = wxTheAssertHandler;
wxTheAssertHandler = handler;
return old;
}
#else // !wxDEBUG_LEVEL
// provide empty subs in case assertions are completely disabled
//
// NB: can't use WXUNUSED() here as we're included from wx/defs.h before it is
// defined
inline wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t /* handler */)
{
return NULL;
}
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
// simply a synonym for wxSetAssertHandler(NULL)
inline void wxDisableAsserts() { wxSetAssertHandler(NULL); }
#if wxDEBUG_LEVEL
/*
wxOnAssert() is used by the debugging macros defined below. Different
overloads are needed because these macros can be used with or without _T().
All of them are implemented in src/common/appcmn.cpp and unconditionally
call wxTheAssertHandler so the caller must check that it is non-NULL
(assert macros do it).
*/
#if wxUSE_UNICODE
// these overloads are the ones typically used by debugging macros: we have to
// provide wxChar* msg version because it's common to use _T() in the macros
// and finally, we can't use const wx(char)* msg = NULL, because that would
// be ambiguous
//
// also notice that these functions can't be inline as wxString is not defined
// yet (and can't be as wxString code itself may use assertions)
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const char *msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxChar *msg);
#endif /* wxUSE_UNICODE */
// this version is for compatibility with wx 2.8 Unicode build only, we don't
// use it ourselves any more except in ANSI-only build in which case it is all
// we need
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *file,
int line,
const char *func,
const wxChar *cond,
const wxChar *msg = NULL);
// these overloads work when msg passed to debug macro is a string and we
// also have to provide wxCStrData overload to resolve ambiguity which would
// otherwise arise from wxASSERT( s.c_str() )
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& file,
int line,
const wxString& func,
const wxString& cond);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxCStrData& msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxString& msg);
#endif // wxDEBUG_LEVEL
// ----------------------------------------------------------------------------
// Debugging macros
// ----------------------------------------------------------------------------
/*
Assertion macros: check if the condition is true and call assert handler
(which will by default notify the user about failure) if it isn't.
wxASSERT and wxFAIL macros as well as wxTrap() function do nothing at all
if wxDEBUG_LEVEL is 0 however they do check their conditions at default
debug level 1, unlike the previous wxWidgets versions.
wxASSERT_LEVEL_2 is meant to be used for "expensive" asserts which should
normally be disabled because they have a big impact on performance and so
this macro only does anything if wxDEBUG_LEVEL >= 2.
*/
#if wxDEBUG_LEVEL
// call this function to break into the debugger unconditionally (assuming
// the program is running under debugger, of course)
extern void WXDLLIMPEXP_BASE wxTrap();
// assert checks if the condition is true and calls the assert handler with
// the provided message if it isn't
//
// NB: the macro is defined like this to ensure that nested if/else
// statements containing it are compiled in the same way whether it is
// defined as empty or not; also notice that we can't use ";" instead
// of "{}" as some compilers warn about "possible unwanted ;" then
#define wxASSERT_MSG(cond, msg) \
if ( !wxTheAssertHandler || (cond) ) \
{} \
else \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
// a version without any additional message, don't use unless condition
// itself is fully self-explanatory
#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
// wxFAIL is a special form of assert: it always triggers (and so is
// usually used in normally unreachable code)
#define wxFAIL_COND_MSG(cond, msg) \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("Assert failure", msg)
#define wxFAIL wxFAIL_MSG((const char*)NULL)
#else // !wxDEBUG_LEVEL
#define wxTrap()
#define wxASSERT(cond)
#define wxASSERT_MSG(cond, msg)
#define wxFAIL
#define wxFAIL_MSG(msg)
#define wxFAIL_COND_MSG(cond, msg)
#endif // wxDEBUG_LEVEL
#if wxDEBUG_LEVEL >= 2
#define wxASSERT_LEVEL_2_MSG(cond, msg) wxASSERT_MSG(cond, msg)
#define wxASSERT_LEVEL_2(cond) wxASSERT(cond)
#else // wxDEBUG_LEVEL < 2
#define wxASSERT_LEVEL_2_MSG
#define wxASSERT_LEVEL_2
#endif
/*
wxCHECK macros always check their conditions, setting debug level to 0 only
makes them silent in case of failure, otherwise -- including at default
debug level 1 -- they call the assert handler if the condition is false
They are supposed to be used only in invalid situation: for example, an
invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
dereferencing it and causing core dump the function might use
wxCHECK_RET( p != NULL, "pointer can't be NULL" )
*/
// check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
// as wxCHECK but with a message explaining why we fail
#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
// check that expression is true, perform op if not
#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
// as wxCHECK2 but with a message explaining why we fail
// the generic macro: takes the condition to check, the statement to be execute
// in case the condition is false and the message to pass to the assert handler
#define wxCHECK2_MSG(cond, op, msg) \
if ( cond ) \
{} \
@@ -225,6 +305,15 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
} \
struct wxDummyCheckStruct /* just to force a semicolon */
// check which returns with the specified return code if the condition fails
#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
// check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
// check that expression is true, perform op if not
#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
// special form of wxCHECK2: as wxCHECK, but for use in void functions
//
// NB: there is only one form (with msg parameter) and it's intentional:
@@ -233,11 +322,12 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
// to begin with...)
#define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
// ----------------------------------------------------------------------------
// Compile time asserts
//
// Unlike the normal assert and related macros above which are checked during
// the program tun-time the macros below will result in a compilation error if
// the program run-time the macros below will result in a compilation error if
// the condition they check is false. This is usually used to check the
// expressions containing sizeof()s which cannot be tested with the
// preprocessor. If you can use the #if's, do use them as you can give a more
@@ -295,6 +385,7 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
wxMAKE_BITSIZE_MSG(type, size))
// ----------------------------------------------------------------------------
// other miscellaneous debugger-related functions
// ----------------------------------------------------------------------------
@@ -311,4 +402,28 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
inline bool wxIsDebuggerRunning() { return false; }
#endif // Mac/!Mac
// An assert helper used to avoid warning when testing constant expressions,
// i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about
// expression being always true, but not using
// wxASSERT( wxAssertIsEqual(sizeof(int), 4) )
//
// NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no
// longer be used.
extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
// Use of wxFalse instead of false suppresses compiler warnings about testing
// constant expression
extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#define wxAssertFailure wxFalse
// This is similar to WXUNUSED() and useful for parameters which are only used
// in assertions.
#if wxDEBUG_LEVEL
#define WXUNUSED_UNLESS_DEBUG(param) param
#else
#define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param)
#endif
#endif // _WX_DEBUG_H_

7
include/wx/defs.h
View File

@@ -661,13 +661,6 @@ typedef short int WXTYPE;
#define WXUNUSED(identifier) identifier
#endif
/* some arguments are only used in debug mode, but unused in release one */
#ifdef __WXDEBUG__
#define WXUNUSED_UNLESS_DEBUG(param) param
#else
#define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param)
#endif
/* some arguments are not used in unicode mode */
#if wxUSE_UNICODE
#define WXUNUSED_IN_UNICODE(param) WXUNUSED(param)

17
include/wx/event.h
View File

@@ -1636,7 +1636,9 @@ private:
wxEVT_PAINT_ICON
*/
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
#if wxDEBUG_LEVEL && (defined(__WXMSW__) || defined(__WXPM__))
#define wxHAS_PAINT_DEBUG
// see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined
extern WXDLLIMPEXP_CORE int g_isPainting;
#endif // debug
@@ -1647,15 +1649,15 @@ public:
wxPaintEvent(int Id = 0)
: wxEvent(Id, wxEVT_PAINT)
{
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
// set the internal flag for the duration of processing of WM_PAINT
#ifdef wxHAS_PAINT_DEBUG
// set the internal flag for the duration of redrawing
g_isPainting++;
#endif // debug
}
// default copy ctor and dtor are normally fine, we only need them to keep
// g_isPainting updated in debug build
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__))
#ifdef wxHAS_PAINT_DEBUG
wxPaintEvent(const wxPaintEvent& event)
: wxEvent(event)
{
@@ -2804,10 +2806,11 @@ public:
// Clear table
void Clear();
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
// Clear all tables
#if wxUSE_MEMORY_TRACING
// Clear all tables: only used to work around problems in memory tracing
// code
static void ClearAll();
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
#endif // wxUSE_MEMORY_TRACING
protected:
// Init the hash table with the entries of the static event table.

5
include/wx/gtk/app.h
View File

@@ -45,13 +45,11 @@ public:
virtual bool Initialize(int& argc, wxChar **argv);
virtual void CleanUp();
#ifdef __WXDEBUG__
virtual void OnAssertFailure(const wxChar *file,
int line,
const wxChar *func,
const wxChar *cond,
const wxChar *msg);
#endif // __WXDEBUG__
// GTK-specific methods
// -------------------
@@ -80,9 +78,8 @@ public:
private:
// true if we're inside an assert modal dialog
#ifdef __WXDEBUG__
bool m_isInAssert;
#endif // __WXDEBUG__
#if wxUSE_THREADS
wxMutex* m_idleMutex;
#endif

10
include/wx/gtk1/app.h
View File

@@ -45,11 +45,13 @@ public:
static bool InitialzeVisual();
#ifdef __WXDEBUG__
virtual void OnAssert(const wxChar *file, int line, const wxChar *cond, const wxChar *msg);
virtual void OnAssertFailure(const wxChar *file,
int line,
const wxChar *func,
const wxChar *cond,
const wxChar *msg);
bool IsInAssert() const { return m_isInAssert; }
#endif // __WXDEBUG__
gint m_idleTag;
void RemoveIdleTag();
@@ -66,9 +68,7 @@ public:
private:
// true if we're inside an assert modal dialog
#ifdef __WXDEBUG__
bool m_isInAssert;
#endif // __WXDEBUG__
DECLARE_DYNAMIC_CLASS(wxApp)
};

4
include/wx/hyperlink.h
View File

@@ -80,10 +80,6 @@ public:
void SendEvent();
};
#ifndef __WXDEBUG__
inline void wxHyperlinkCtrlBase::CheckParams(const wxString&, const wxString&, long) { }
#endif
// ----------------------------------------------------------------------------
// wxHyperlinkEvent
// ----------------------------------------------------------------------------

21
include/wx/memory.h
View File

@@ -9,24 +9,17 @@
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MEMORYH__
#define _WX_MEMORYH__
#ifndef _WX_MEMORY_H_
#define _WX_MEMORY_H_
#include "wx/defs.h"
#include "wx/string.h"
#include "wx/msgout.h"
/*
The macro which will be expanded to include the file and line number
info, or to be a straight call to the new operator.
*/
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#if wxUSE_MEMORY_TRACING || wxUSE_DEBUG_CONTEXT
#include <stddef.h>
#ifdef __WXDEBUG__
WXDLLIMPEXP_BASE void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = false);
WXDLLIMPEXP_BASE void wxDebugFree(void * buf, bool isVect = false);
@@ -129,7 +122,6 @@ inline void operator delete[](void* pData, wxChar* /* fileName */, int /* lineNu
}
#endif // __VISUALC__>=1200
#endif // wxUSE_GLOBAL_MEMORY_OPERATORS
#endif // __WXDEBUG__
//**********************************************************************************
@@ -357,7 +349,7 @@ void WXDLLIMPEXP_BASE wxTraceLevel(int level, const wxChar *fmt ...) WX_ATTRIBUT
#define WXTRACE wxTrace
#define WXTRACELEVEL wxTraceLevel
#else // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#else // wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#define WXDEBUG_DUMPDELAYCOUNTER
@@ -374,7 +366,6 @@ void WXDLLIMPEXP_BASE wxTraceLevel(int level, const wxChar *fmt ...) WX_ATTRIBUT
#define WXTRACE true ? (void)0 : wxTrace
#define WXTRACELEVEL true ? (void)0 : wxTraceLevel
#endif // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#endif // wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#endif
// _WX_MEMORYH__
#endif // _WX_MEMORY_H_

2
include/wx/msgdlg.h
View File

@@ -140,7 +140,6 @@ public:
// change the dialog style flag
void SetMessageDialogStyle(long style)
{
#ifdef __WXDEBUG__
wxASSERT_MSG( ((style & wxYES_NO) == wxYES_NO) || !(style & wxYES_NO),
"wxYES and wxNO may only be used together" );
@@ -161,7 +160,6 @@ public:
if ((style & wxCANCEL_DEFAULT) != 0 && (style & wxNO_DEFAULT) != 0)
wxFAIL_MSG("only one default button can be specified");
#endif
m_dialogStyle = style;
}

2
include/wx/msw/bitmap.h
View File

@@ -174,10 +174,8 @@ public:
void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
#ifdef __WXDEBUG__
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
#endif // __WXDEBUG__
protected:
virtual wxGDIImageRefData *CreateData() const;

2
include/wx/msw/private.h
View File

@@ -692,14 +692,12 @@ public:
{
if ( m_hGlobal && !GlobalUnlock(m_hGlobal) )
{
#ifdef __WXDEBUG__
// this might happen simply because the block became unlocked
DWORD dwLastError = ::GetLastError();
if ( dwLastError != NO_ERROR )
{
wxLogApiError(_T("GlobalUnlock"), dwLastError);
}
#endif // __WXDEBUG__
}
}

48
include/wx/object.h
View File

@@ -328,20 +328,16 @@ name##PluginSentinel m_pluginsentinel;
#define wxDynamicCastThis(className) \
(IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0)
#ifdef __WXDEBUG__
inline void* wxCheckCast(void *ptr)
// FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly
// choosing the template function to call
template <class T>
inline T *wxCheckCast(const void *ptr, T * = NULL)
{
wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") );
return ptr;
wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" );
return const_cast<T *>(static_cast<const T *>(ptr));
}
#define wxStaticCast(obj, className) \
((className *)wxCheckCast(wxDynamicCast(obj, className)))
#else // !__WXDEBUG__
#define wxStaticCast(obj, className) \
const_cast<className *>(static_cast<const className *>(obj))
#endif // __WXDEBUG__
#define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL)
// ----------------------------------------------------------------------------
// set up memory debugging macros
@@ -359,7 +355,7 @@ inline void* wxCheckCast(void *ptr)
_WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int )
*/
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING
#if wxUSE_MEMORY_TRACING
// All compilers get this one
#define _WX_WANT_NEW_SIZET_WXCHAR_INT
@@ -400,7 +396,7 @@ inline void* wxCheckCast(void *ptr)
#endif // wxUSE_ARRAY_MEMORY_OPERATORS
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING
#endif // wxUSE_MEMORY_TRACING
// ----------------------------------------------------------------------------
// wxObjectRefData: ref counted data meant to be stored in wxObject
@@ -653,24 +649,16 @@ private :
// more debugging macros
// ----------------------------------------------------------------------------
// Redefine new to be the debugging version. This doesn't work with all
// compilers, in which case you need to use WXDEBUG_NEW explicitly if you wish
// to use the debugging version.
#ifdef __WXDEBUG__
#if wxUSE_DEBUG_NEW_ALWAYS
#define WXDEBUG_NEW new(__TFILE__,__LINE__)
#if wxUSE_DEBUG_NEW_ALWAYS
#if wxUSE_GLOBAL_MEMORY_OPERATORS
#define new WXDEBUG_NEW
#elif defined(__VISUALC__)
// Including this file redefines new and allows leak reports to
// contain line numbers
#include "wx/msw/msvcrt.h"
#endif
#endif // wxUSE_DEBUG_NEW_ALWAYS
#else // !__WXDEBUG__
#define WXDEBUG_NEW new
#endif // __WXDEBUG__/!__WXDEBUG__
#if wxUSE_GLOBAL_MEMORY_OPERATORS
#define new WXDEBUG_NEW
#elif defined(__VISUALC__)
// Including this file redefines new and allows leak reports to
// contain line numbers
#include "wx/msw/msvcrt.h"
#endif
#endif // wxUSE_DEBUG_NEW_ALWAYS
#endif // _WX_OBJECTH__

5
include/wx/palmos/bitmap.h
View File

@@ -147,11 +147,6 @@ public:
void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
#ifdef __WXDEBUG__
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
#endif // __WXDEBUG__
protected:
// common part of all ctors
void Init();

7
include/wx/propgrid/propgrid.h
View File

@@ -87,9 +87,7 @@ public:
int m_extraStyle; // global extra style
#ifdef __WXDEBUG__
int m_warnings;
#endif
int HasExtraStyle( int style ) const { return (m_extraStyle & style); }
};
@@ -1753,11 +1751,6 @@ protected:
*/
void CorrectEditorWidgetPosY();
#ifdef __WXDEBUG__
void _log_items();
void OnScreenNote( const wxChar* format, ... );
#endif
/** Deselect current selection, if any. Returns true if success
(ie. validator did not intercept). */
bool DoClearSelection();

7
include/wx/stringops.h
View File

@@ -65,9 +65,10 @@ struct WXDLLIMPEXP_BASE wxStringOperationsUtf8
// checks correctness of UTF-8 sequence
static bool IsValidUtf8String(const char *c,
size_t len = wxStringImpl::npos);
#ifdef __WXDEBUG__
static bool IsValidUtf8LeadByte(unsigned char c);
#endif
static bool IsValidUtf8LeadByte(unsigned char c)
{
return (c <= 0x7F) || (c >= 0xC2 && c <= 0xF4);
}
// table of offsets to skip forward when iterating over UTF-8 sequence
static const unsigned char ms_utf8IterTable[256];

2
include/wx/unix/apptrait.h
View File

@@ -76,7 +76,7 @@ public:
wxArrayString& desc) const;
#endif // __WXGTK20____
#if defined(__WXDEBUG__) && defined(__WXGTK20__)
#if defined(__WXGTK20__)
virtual bool ShowAssertDialog(const wxString& msg);
#endif

4
include/wx/x11/app.h
View File

@@ -55,10 +55,6 @@ public:
// Processes an X event.
virtual bool ProcessXEvent(WXEvent* event);
#ifdef __WXDEBUG__
virtual void OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg);
#endif // __WXDEBUG__
public:
// Implementation
virtual bool Initialize(int& argc, wxChar **argv);

2
include/wx/x11/privx.h
View File

@@ -67,9 +67,7 @@ void wxAllocNearestColor(Display *display,Colormap colormap,XColor *xcolor);
void wxAllocColor(Display *display,Colormap colormap,XColor *xcolor);
// For debugging
#ifdef __WXDEBUG__
wxString wxGetXEventName(XEvent& event);
#endif
// Is the window visible?
bool wxWindowIsVisible(Window win);