]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/debug.h
fix wxTextDataObject::GetDataHere and SetData functions (under wxMSW) so that they...
[wxWidgets.git] / include / wx / debug.h
index f7815a9844da32e8e10acbf40e23945e656cbd80..fab0b7c3b3d118b27ea8d9c368970055d76479ce 100644 (file)
 #ifndef   _WX_DEBUG_H_
 #define   _WX_DEBUG_H_
 
+#ifndef __WXPALMOS5__
 #ifndef __WXWINCE__
 #include  <assert.h>
 #endif
+#endif // ! __WXPALMOS5__
 #include  <limits.h>            /*  for CHAR_BIT used below */
 
 #include  "wx/chartype.h"     /*  for __TFILE__ and wxChar */
@@ -92,7 +94,7 @@
   /*
     This function is called whenever one of debugging macros fails (i.e.
     condition is false in an assertion). To customize its behaviour, override
-    wxApp::OnAssert().
+    wxApp::OnAssertFailure().
 
     Parameters:
        szFile and nLine - file name and line number of the ASSERT
        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, NULL)
+  #define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
 
 
   /*  assert with additional message explaining its cause */
 
-  /*  compilers can give a warning (such as "possible unwanted ;") when using */
-  /*  the default definition of wxASSERT_MSG so we provide an alternative */
-  #if defined(__MWERKS__)
-    #define wxASSERT_MSG(cond, msg)                                           \
-      if ( cond )                                                             \
-      {}                                                                      \
-      else                                                                    \
-          wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(#cond), msg)
-  #else
-    #define wxASSERT_MSG(cond, msg)                                           \
-      if ( cond )                                                             \
-          ;                                                                   \
-      else                                                                    \
-          wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(#cond), msg)
-  #endif
+  /*  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(NULL)
+  #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(__TFILE__, __LINE__,  __WXFUNCTION__, _T(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 */
 */
 
 /*  check that expression is true, "return" if not (also FAILs in debug mode) */
-#define wxCHECK(cond, rc)            wxCHECK_MSG(cond, rc, NULL)
+#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, NULL)
+#define wxCHECK2(cond, op)           wxCHECK2_MSG(cond, op, (const char*)NULL)
 
 /*  as wxCHECK2 but with a message explaining why we fail */
 
-/* see comment near the definition of wxASSERT_MSG for the # if/else reason */
-#if defined(__MWERKS__)
-    #define wxCHECK2_MSG(cond, op, msg)                                       \
-        if ( cond )                                                           \
-        {}                                                                    \
-        else                                                                  \
-        {                                                                     \
-            wxFAIL_COND_MSG(#cond, msg);                                      \
-            op;                                                               \
-        }                                                                     \
-        struct wxDummyCheckStruct /* just to force a semicolon */
-#else
-    #define wxCHECK2_MSG(cond, op, msg)                                       \
-        if ( cond )                                                           \
-            ;                                                                 \
-        else                                                                  \
-        {                                                                     \
-            wxFAIL_COND_MSG(#cond, msg);                                      \
-            op;                                                               \
-        }                                                                     \
-        struct wxDummyCheckStruct /* just to force a semicolon */
-#endif
+#define wxCHECK2_MSG(cond, op, msg)                                       \
+    if ( cond )                                                           \
+    {}                                                                    \
+    else                                                                  \
+    {                                                                     \
+        wxFAIL_COND_MSG(#cond, msg);                                      \
+        op;                                                               \
+    }                                                                     \
+    struct wxDummyCheckStruct /* just to force a semicolon */
 
 /*  special form of wxCHECK2: as wxCHECK, but for use in void functions */
 /*  */