static void SetResolution(int ppi);
static int GetResolution();
- WX_DEFINE_VARARG_FUNC_VOID(PsPrintf, 1, (const wxString&), DoPsPrintfFormat)
+ WX_DEFINE_VARARG_FUNC_VOID(PsPrintf, 1, (const wxString&),
+ DoPsPrintfFormatWchar, DoPsPrintfFormatUtf8)
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
- WX_DEFINE_VARARG_FUNC_VOID(PsPrintf, 1, (const char*), DoPsPrintfFormat)
- WX_DEFINE_VARARG_FUNC_VOID(PsPrintf, 1, (const wchar_t*), DoPsPrintfFormat)
+ WX_DEFINE_VARARG_FUNC_VOID(PsPrintf, 1, (const char*),
+ DoPsPrintfFormatWchar, DoPsPrintfFormatUtf8)
+ WX_DEFINE_VARARG_FUNC_VOID(PsPrintf, 1, (const wchar_t*),
+ DoPsPrintfFormatWchar, DoPsPrintfFormatUtf8)
#endif
+
void PsPrint( const wxString& psdata );
void PsPrint( int ch );
private:
- void DoPsPrintfFormat(const wxString& fmt, ... );
+#if !wxUSE_UTF8_LOCALE_ONLY
+ void DoPsPrintfFormatWchar(const wxChar *fmt, ... );
+#endif
+#if wxUSE_UNICODE_UTF8
+ void DoPsPrintfFormatUtf8(const char *fmt, ... );
+#endif
static float ms_PSScaleFactor;
#define DECLARE_LOG_FUNCTION(level) \
extern void WXDLLIMPEXP_BASE \
- wxDoLog##level(const wxString& format, ...); \
+ wxDoLog##level##Wchar(const wxChar *format, ...); \
+ extern void WXDLLIMPEXP_BASE \
+ wxDoLog##level##Utf8(const char *format, ...); \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
- 1, (const wxString&), wxDoLog##level) \
+ 1, (const wxString&), \
+ wxDoLog##level##Wchar, wxDoLog##level##Utf8) \
DECLARE_LOG_FUNCTION_WATCOM(level) \
extern void WXDLLIMPEXP_BASE wxVLog##level(const wxString& format, \
va_list argptr)
// something too big for Borland C++ to handle
#define DECLARE_LOG_FUNCTION_WATCOM(level) \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
- 1, (const char*), wxDoLog##level) \
+ 1, (const char*), \
+ wxDoLog##level##Wchar, \
+ wxDoLog##level##Utf8) \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
- 1, (const wchar_t*), wxDoLog##level) \
+ 1, (const wchar_t*), \
+ wxDoLog##level##Wchar, \
+ wxDoLog##level##Utf8) \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
- 1, (const wxCStrData&), wxDoLog##level)
+ 1, (const wxCStrData&), \
+ wxDoLog##level##Wchar, \
+ wxDoLog##level##Utf8)
#else
#define DECLARE_LOG_FUNCTION_WATCOM(level)
#endif
#define DECLARE_LOG_FUNCTION2_EXP(level, argclass, arg, expdecl) \
- extern void expdecl wxDoLog##level(argclass arg, \
- const wxString& format, ...); \
+ extern void expdecl wxDoLog##level##Wchar(argclass arg, \
+ const wxChar *format, ...); \
+ extern void expdecl wxDoLog##level##Utf8(argclass arg, \
+ const char *format, ...); \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
2, (argclass, const wxString&), \
- wxDoLog##level) \
+ wxDoLog##level##Wchar, wxDoLog##level##Utf8) \
DECLARE_LOG_FUNCTION2_EXP_WATCOM(level, argclass, arg, expdecl) \
extern void expdecl wxVLog##level(argclass arg, \
const wxString& format, \
#define DECLARE_LOG_FUNCTION2_EXP_WATCOM(level, argclass, arg, expdecl) \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
2, (argclass, const char*), \
- wxDoLog##level) \
+ wxDoLog##level##Wchar, \
+ wxDoLog##level##Utf8) \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
2, (argclass, const wchar_t*), \
- wxDoLog##level) \
+ wxDoLog##level##Wchar, \
+ wxDoLog##level##Utf8) \
WX_DEFINE_VARARG_FUNC_VOID(wxLog##level, \
2, (argclass, const wxCStrData&), \
- wxDoLog##level)
+ wxDoLog##level##Wchar, \
+ wxDoLog##level##Utf8)
#else
#define DECLARE_LOG_FUNCTION2_EXP_WATCOM(level, argclass, arg, expdecl)
#endif
#include "wx/dynarray.h"
#include "wx/arrstr.h"
+#include <stdarg.h>
+
// fwd decls
class WXDLLIMPEXP_BASE wxIconLocation;
class WXDLLIMPEXP_BASE wxFileTypeImpl;
class WXDLLIMPEXP_BASE wxFileTypeInfo
{
private:
- void VarArgInit(const wxString& mimeType,
- const wxString& openCmd,
- const wxString& printCmd,
- const wxString& desc,
- // the other parameters form a NULL terminated list of
- // extensions
- ...);
+ void DoVarArgInit(const wxString& mimeType,
+ const wxString& openCmd,
+ const wxString& printCmd,
+ const wxString& desc,
+ va_list argptr);
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+ void VarArgInitWchar(const wxChar *mimeType,
+ const wxChar *openCmd,
+ const wxChar *printCmd,
+ const wxChar *desc,
+ // the other parameters form a NULL terminated list of
+ // extensions
+ ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+ void VarArgInitUtf8(const char *mimeType,
+ const char *openCmd,
+ const char *printCmd,
+ const char *desc,
+ // the other parameters form a NULL terminated list of
+ // extensions
+ ...);
+#endif
public:
// ctors
// a normal item
WX_DEFINE_VARARG_FUNC_CTOR(wxFileTypeInfo,
4, (const wxString&, const wxString&,
const wxString&, const wxString&),
- VarArgInit)
+ VarArgInitWchar, VarArgInitUtf8)
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
WX_DEFINE_VARARG_FUNC_CTOR(wxFileTypeInfo,
4, (const char*, const char*,
const char*, const char*),
- VarArgInit)
+ VarArgInitWchar, VarArgInitUtf8)
WX_DEFINE_VARARG_FUNC_CTOR(wxFileTypeInfo,
4, (const wchar_t*, const wchar_t*,
const wchar_t*, const wchar_t*),
- VarArgInit)
+ VarArgInitWchar, VarArgInitUtf8)
WX_DEFINE_VARARG_FUNC_CTOR(wxFileTypeInfo,
4, (const wxCStrData&, const wxCStrData&,
const wxCStrData&, const wxCStrData&),
- VarArgInit)
+ VarArgInitWchar, VarArgInitUtf8)
#endif
// the array elements correspond to the parameters of the ctor above in
// show a message to the user
// void Printf(const wxString& format, ...) = 0;
- WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wxString&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wxString&),
+ DoPrintfWchar, DoPrintfUtf8)
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
- WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const char*), DoPrintf)
- WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wchar_t*), DoPrintf)
- WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wxCStrData&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const char*),
+ DoPrintfWchar, DoPrintfUtf8)
+ WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wchar_t*),
+ DoPrintfWchar, DoPrintfUtf8)
+ WX_DEFINE_VARARG_FUNC_VOID(Printf, 1, (const wxCStrData&),
+ DoPrintfWchar, DoPrintfUtf8)
#endif
protected:
// NB: this is pure virtual so that it can be implemented in dllexported
// wxMessagOutput class
- virtual void DoPrintf(const wxString& format, ...) = 0;
+#if !wxUSE_UTF8_LOCALE_ONLY
+ virtual void DoPrintfWchar(const wxChar *format, ...) = 0;
+#endif
+#if wxUSE_UNICODE_UTF8
+ virtual void DoPrintfUtf8(const char *format, ...) = 0;
+#endif
// called by DoPrintf() to output formatted string
virtual void Output(const wxString& str) = 0;
static wxMessageOutput* Set(wxMessageOutput* msgout);
protected:
- virtual void DoPrintf(const wxString& format, ...);
+#if !wxUSE_UTF8_LOCALE_ONLY
+ virtual void DoPrintfWchar(const wxChar *format, ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+ virtual void DoPrintfUtf8(const char *format, ...);
+#endif
virtual void Output(const wxString& str) = 0;
private:
protected:
wxStringPrintfMixinBase() {}
- int DoPrintf(const wxString& format, ...);
- static wxString DoFormat(const wxString& format, ...);
+#if !wxUSE_UTF8_LOCALE_ONLY
+ int DoPrintfWchar(const wxChar *format, ...);
+ static wxString DoFormatWchar(const wxChar *format, ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+ int DoPrintfUtf8(const char *format, ...);
+ static wxString DoFormatUtf8(const char *format, ...);
+#endif
};
// this class contains template wrappers for wxString's vararg methods, it's
// if !wxNEEDS_WXSTRING_PRINTF_MIXIN:
// static wxString Format(const wString& format, ...) ATTRIBUTE_PRINTF_1;
- WX_DEFINE_VARARG_FUNC2_SANS_N0(static typename StringReturnType<T1>::type,
- Format, 1, (const wxString&),
- DoFormat, DoFormat)
+ WX_DEFINE_VARARG_FUNC_SANS_N0(static typename StringReturnType<T1>::type,
+ Format, 1, (const wxString&),
+ DoFormatWchar, DoFormatUtf8)
// We have to implement the version without template arguments manually
// because of the StringReturnType<> hack, although WX_DEFINE_VARARG_FUNC
// normally does it itself. It has to be a template so that we can use
}
// int Printf(const wxString& format, ...);
- WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxString&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxString&),
+ DoPrintfWchar, DoPrintfUtf8)
// int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
- WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxString&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxString&),
+ DoPrintfWchar, DoPrintfUtf8)
protected:
wxStringPrintfMixin() : wxStringPrintfMixinBase() {}
// as sprintf(), returns the number of characters written or < 0 on error
// (take 'this' into account in attribute parameter count)
// int Printf(const wxString& format, ...);
- WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxString&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxString&),
+ DoPrintfWchar, DoPrintfUtf8)
#ifdef __WATCOMC__
- WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const char*), DoPrintf)
- WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wchar_t*), DoPrintf)
- WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxCStrData&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const char*)
+ DoPrintfWchar, DoPrintfUtf8)
+ WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wchar_t*)
+ DoPrintfWchar, DoPrintfUtf8)
+ WX_DEFINE_VARARG_FUNC(int, Printf, 1, (const wxCStrData&)
+ DoPrintfWchar, DoPrintfUtf8)
#endif
#endif // !wxNEEDS_WXSTRING_PRINTF_MIXIN
// as vprintf(), returns the number of characters written or < 0 on error
#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
// returns the string containing the result of Printf() to it
// static wxString Format(const wxString& format, ...) ATTRIBUTE_PRINTF_1;
- WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxString&), DoFormat)
+ WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxString&),
+ DoFormatWchar, DoFormatUtf8)
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
- WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const char*), DoFormat)
- WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wchar_t*), DoFormat)
- WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxCStrData&), DoFormat)
+ WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const char*),
+ DoFormatWchar, DoFormatUtf8)
+ WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wchar_t*),
+ DoFormatWchar, DoFormatUtf8)
+ WX_DEFINE_VARARG_FUNC(static wxString, Format, 1, (const wxCStrData&),
+ DoFormatWchar, DoFormatUtf8)
#endif
#endif
// the same as above, but takes a va_list
// use Printf()
// (take 'this' into account in attribute parameter count)
// int sprintf(const wxString& format, ...) ATTRIBUTE_PRINTF_2;
- WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxString&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxString&),
+ DoPrintfWchar, DoPrintfUtf8)
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
- WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const char*), DoPrintf)
- WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wchar_t*), DoPrintf)
- WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxCStrData&), DoPrintf)
+ WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const char*),
+ DoPrintfWchar, DoPrintfUtf8)
+ WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wchar_t*),
+ DoPrintfWchar, DoPrintfUtf8)
+ WX_DEFINE_VARARG_FUNC(int, sprintf, 1, (const wxCStrData&),
+ DoPrintfWchar, DoPrintfUtf8)
#endif
#endif // wxNEEDS_WXSTRING_PRINTF_MIXIN
#endif // !wxUSE_STL_BASED_WXSTRING
#ifndef wxNEEDS_WXSTRING_PRINTF_MIXIN
- int DoPrintf(const wxString& format, ...);
- static wxString DoFormat(const wxString& format, ...);
+ #if !wxUSE_UTF8_LOCALE_ONLY
+ int DoPrintfWchar(const wxChar *format, ...);
+ static wxString DoFormatWchar(const wxChar *format, ...);
+ #endif
+ #if wxUSE_UNICODE_UTF8
+ int DoPrintfUtf8(const char *format, ...);
+ static wxString DoFormatUtf8(const char *format, ...);
+ #endif
#endif
#if !wxUSE_STL_BASED_WXSTRING
// if wxUSE_UNICODE_UTF8 and running under UTF-8 locale
// (ignored otherwise) [fprintf]
//
-#define WX_DEFINE_VARARG_FUNC2(rettype, name, numfixed, fixed, impl, implUtf8)\
+#define WX_DEFINE_VARARG_FUNC(rettype, name, numfixed, fixed, impl, implUtf8) \
_WX_VARARG_DEFINE_FUNC_N0(rettype, name, impl, implUtf8, numfixed, fixed) \
- WX_DEFINE_VARARG_FUNC2_SANS_N0(rettype, name, numfixed, fixed, impl, implUtf8)
+ WX_DEFINE_VARARG_FUNC_SANS_N0(rettype, name, numfixed, fixed, impl, implUtf8)
// ditto, but without the version with 0 template/vararg arguments
-#define WX_DEFINE_VARARG_FUNC2_SANS_N0(rettype, name, \
+#define WX_DEFINE_VARARG_FUNC_SANS_N0(rettype, name, \
numfixed, fixed, impl, implUtf8) \
_WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
_WX_VARARG_DEFINE_FUNC, \
rettype, name, impl, implUtf8, numfixed, fixed)
-// like WX_DEFINE_VARARG_FUNC2, but for impl=implUtf8:
-#define WX_DEFINE_VARARG_FUNC(rettype, name, numfixed, fixed, impl) \
- WX_DEFINE_VARARG_FUNC2(rettype, name, numfixed, fixed, impl, impl)
-
-// Like WX_DEFINE_VARARG_FUNC2, but for variadic functions that don't return
+// Like WX_DEFINE_VARARG_FUNC, but for variadic functions that don't return
// a value.
-#define WX_DEFINE_VARARG_FUNC_VOID2(name, numfixed, fixed, impl, implUtf8) \
+#define WX_DEFINE_VARARG_FUNC_VOID(name, numfixed, fixed, impl, implUtf8) \
_WX_VARARG_DEFINE_FUNC_VOID_N0(name, impl, implUtf8, numfixed, fixed) \
_WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
_WX_VARARG_DEFINE_FUNC_VOID, \
void, name, impl, implUtf8, numfixed, fixed)
-// like WX_DEFINE_VARARG_FUNC_VOID2, but for impl=implUtf8:
-#define WX_DEFINE_VARARG_FUNC_VOID(name, numfixed, fixed, impl) \
- WX_DEFINE_VARARG_FUNC_VOID2(name, numfixed, fixed, impl, impl)
-
// Like WX_DEFINE_VARARG_FUNC_VOID, but instead of wrapping an implementation
// function, does nothing in defined functions' bodies.
//
void, name, dummy, dummy, numfixed, fixed)
// Like WX_DEFINE_VARARG_FUNC_CTOR, but for defining template constructors
-#define WX_DEFINE_VARARG_FUNC_CTOR(name, numfixed, fixed, impl) \
- _WX_VARARG_DEFINE_FUNC_CTOR_N0(name, impl, impl, numfixed, fixed) \
+#define WX_DEFINE_VARARG_FUNC_CTOR(name, numfixed, fixed, impl, implUtf8) \
+ _WX_VARARG_DEFINE_FUNC_CTOR_N0(name, impl, implUtf8, numfixed, fixed) \
_WX_VARARG_ITER(_WX_VARARG_MAX_ARGS, \
_WX_VARARG_DEFINE_FUNC_CTOR, \
- void, name, impl, impl, numfixed, fixed)
+ void, name, impl, implUtf8, numfixed, fixed)
// ----------------------------------------------------------------------------
// wxArgNormalizer*<T> converters
#define _WX_VARARG_ARG(i) T##i a##i
// Like _WX_VARARG_ARG_UNUSED, but outputs argument's type with WXUNUSED:
-#define _WX_VARARG_ARG_UNUSED(i) T##i WXUNUSED(a##i)
+#define _WX_VARARG_ARG_UNUSED(i) T##i WXUNUSED(a##i)
// Generates code snippet for i-th type in vararg function's template<...>:
#define _WX_VARARG_TEMPL(i) typename T##i
// we'll also need wxArgNormalizer<T> specializations for char,
// wchar_t, wxUniChar and wxUniCharRef to handle this correctly
-WX_DEFINE_VARARG_FUNC2(int, wxPrintf, 1, (const wxString&),
- wxCRT_Printf, printf)
-WX_DEFINE_VARARG_FUNC2(int, wxFprintf, 2, (FILE*, const wxString&),
- wxCRT_Fprintf, fprintf)
+WX_DEFINE_VARARG_FUNC(int, wxPrintf, 1, (const wxString&),
+ wxCRT_Printf, printf)
+WX_DEFINE_VARARG_FUNC(int, wxFprintf, 2, (FILE*, const wxString&),
+ wxCRT_Fprintf, fprintf)
// va_list versions of printf functions simply forward to the respective
// CRT function; note that they assume that va_list was created using
// wxSprintf() and friends have to be implemented in two forms, one for
// writing to char* buffer and one for writing to wchar_t*:
-int WXDLLIMPEXP_BASE wxDoSprintf(char *str, const wxString& format, ...);
+#if !wxUSE_UTF8_LOCALE_ONLY
+int WXDLLIMPEXP_BASE wxDoSprintfWchar(char *str, const wxChar *format, ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+int WXDLLIMPEXP_BASE wxDoSprintfUtf8(char *str, const char *format, ...);
+#endif
WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (char*, const wxString&),
- wxDoSprintf)
+ wxDoSprintfWchar, wxDoSprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsprintf(char *str, const wxString& format, va_list argptr);
-int WXDLLIMPEXP_BASE wxDoSnprintf(char *str, size_t size, const wxString& format, ...);
+#if !wxUSE_UTF8_LOCALE_ONLY
+int WXDLLIMPEXP_BASE wxDoSnprintfWchar(char *str, size_t size, const wxChar *format, ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(char *str, size_t size, const char *format, ...);
+#endif
WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (char*, size_t, const wxString&),
- wxDoSnprintf)
+ wxDoSnprintfWchar, wxDoSnprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsnprintf(char *str, size_t size, const wxString& format, va_list argptr);
#if wxUSE_UNICODE
-int WXDLLIMPEXP_BASE wxDoSprintf(wchar_t *str, const wxString& format, ...);
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+int WXDLLIMPEXP_BASE wxDoSprintfWchar(wchar_t *str, const wxChar *format, ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+int WXDLLIMPEXP_BASE wxDoSprintfUtf8(wchar_t *str, const char *format, ...);
+#endif
WX_DEFINE_VARARG_FUNC(int, wxSprintf, 2, (wchar_t*, const wxString&),
- wxDoSprintf)
+ wxDoSprintfWchar, wxDoSprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsprintf(wchar_t *str, const wxString& format, va_list argptr);
-int WXDLLIMPEXP_BASE wxDoSnprintf(wchar_t *str, size_t size, const wxString& format, ...);
+#if !wxUSE_UTF8_LOCALE_ONLY
+int WXDLLIMPEXP_BASE wxDoSnprintfWchar(wchar_t *str, size_t size, const wxChar *format, ...);
+#endif
+#if wxUSE_UNICODE_UTF8
+int WXDLLIMPEXP_BASE wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...);
+#endif
WX_DEFINE_VARARG_FUNC(int, wxSnprintf, 3, (wchar_t*, size_t, const wxString&),
- wxDoSnprintf)
+ wxDoSnprintfWchar, wxDoSnprintfUtf8)
int WXDLLIMPEXP_BASE
wxVsnprintf(wchar_t *str, size_t size, const wxString& format, va_list argptr);
+
#endif // wxUSE_UNICODE
#ifdef __WATCOMC__
}
}
-void wxDoLogGeneric(wxLogLevel level, const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxDoLogGenericWchar(wxLogLevel level, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogGeneric(level, format, argptr);
va_end(argptr);
}
+#endif // wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxDoLogGenericUtf8(wxLogLevel level, const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogGeneric(level, format, argptr);
+ va_end(argptr);
+}
+#endif // wxUSE_UNICODE_UTF8
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+ #define IMPLEMENT_LOG_FUNCTION_WCHAR(level) \
+ void wxDoLog##level##Wchar(const wxChar *format, ...) \
+ { \
+ va_list argptr; \
+ va_start(argptr, format); \
+ wxVLog##level(format, argptr); \
+ va_end(argptr); \
+ }
+#else
+ #define IMPLEMENT_LOG_FUNCTION_WCHAR(level)
+#endif
+
+#if wxUSE_UNICODE_UTF8
+ #define IMPLEMENT_LOG_FUNCTION_UTF8(level) \
+ void wxDoLog##level##Utf8(const char *format, ...) \
+ { \
+ va_list argptr; \
+ va_start(argptr, format); \
+ wxVLog##level(format, argptr); \
+ va_end(argptr); \
+ }
+#else
+ #define IMPLEMENT_LOG_FUNCTION_UTF8(level)
+#endif
#define IMPLEMENT_LOG_FUNCTION(level) \
void wxVLog##level(const wxString& format, va_list argptr) \
wxString::FormatV(format, argptr), time(NULL)); \
} \
} \
- \
- void wxDoLog##level(const wxString& format, ...) \
- { \
- va_list argptr; \
- va_start(argptr, format); \
- wxVLog##level(format, argptr); \
- va_end(argptr); \
- }
+ IMPLEMENT_LOG_FUNCTION_WCHAR(level) \
+ IMPLEMENT_LOG_FUNCTION_UTF8(level)
IMPLEMENT_LOG_FUNCTION(Error)
IMPLEMENT_LOG_FUNCTION(Warning)
#endif
}
-void wxDoLogFatalError(const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxDoLogFatalErrorWchar(const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
// for the others anyhow...
//va_end(argptr);
}
+#endif // wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxDoLogFatalErrorUtf8(const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogFatalError(format, argptr);
+
+ // some compilers warn about unreachable code and it shouldn't matter
+ // for the others anyhow...
+ //va_end(argptr);
+}
+#endif // wxUSE_UNICODE_UTF8
// same as info, but only if 'verbose' mode is on
void wxVLogVerbose(const wxString& format, va_list argptr)
}
}
-void wxDoLogVerbose(const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxDoLogVerboseWchar(const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogVerbose(format, argptr);
va_end(argptr);
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxDoLogVerboseUtf8(const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogVerbose(format, argptr);
+ va_end(argptr);
+}
+#endif // wxUSE_UNICODE_UTF8
// debug functions
#ifdef __WXDEBUG__
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+ #define IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \
+ void wxDoLog##level##Wchar(const wxChar *format, ...) \
+ { \
+ va_list argptr; \
+ va_start(argptr, format); \
+ wxVLog##level(format, argptr); \
+ va_end(argptr); \
+ }
+#else
+ #define IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level)
+#endif
+
+#if wxUSE_UNICODE_UTF8
+ #define IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level) \
+ void wxDoLog##level##Utf8(const char *format, ...) \
+ { \
+ va_list argptr; \
+ va_start(argptr, format); \
+ wxVLog##level(format, argptr); \
+ va_end(argptr); \
+ }
+#else
+ #define IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level)
+#endif
+
#define IMPLEMENT_LOG_DEBUG_FUNCTION(level) \
void wxVLog##level(const wxString& format, va_list argptr) \
{ \
wxString::FormatV(format, argptr), time(NULL)); \
} \
} \
- \
- void wxDoLog##level(const wxString& format, ...) \
- { \
- va_list argptr; \
- va_start(argptr, format); \
- wxVLog##level(format, argptr); \
- va_end(argptr); \
- }
+ IMPLEMENT_LOG_DEBUG_FUNCTION_WCHAR(level) \
+ IMPLEMENT_LOG_DEBUG_FUNCTION_UTF8(level)
+
void wxVLogTrace(const wxString& mask, const wxString& format, va_list argptr)
{
}
}
- void wxDoLogTrace(const wxString& mask, const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+ void wxDoLogTraceWchar(const wxString& mask, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogTrace(mask, format, argptr);
va_end(argptr);
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+ void wxDoLogTraceUtf8(const wxString& mask, const char *format, ...)
+ {
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogTrace(mask, format, argptr);
+ va_end(argptr);
+ }
+#endif // wxUSE_UNICODE_UTF8
void wxVLogTrace(wxTraceMask mask, const wxString& format, va_list argptr)
{
}
}
- void wxDoLogTrace(wxTraceMask mask, const wxString& format, ...)
+#if wxUSE_UTF8_LOCALE_ONLY
+ void wxDoLogTraceWchar(wxTraceMask mask, const wxChar *format, ...)
+ {
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogTrace(mask, format, argptr);
+ va_end(argptr);
+ }
+#endif // wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+ void wxDoLogTraceUtf8(wxTraceMask mask, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogTrace(mask, format, argptr);
va_end(argptr);
}
+#endif // wxUSE_UNICODE_UTF8
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
- void wxDoLogTrace(int mask, const wxString& format, ...)
+ void wxDoLogTrace(int mask, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
}
- void wxDoLogTrace(const char *mask, const wxString& format, ...)
+ void wxDoLogTrace(const char *mask, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
}
- void wxDoLogTrace(const wchar_t *mask, const wxString& format, ...)
+ void wxDoLogTrace(const wchar_t *mask, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogSysError(wxSysErrorCode(), format, argptr);
}
-void WXDLLEXPORT wxDoLogSysError(const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void WXDLLEXPORT wxDoLogSysErrorWchar(const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogSysError(format, argptr);
va_end(argptr);
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void WXDLLEXPORT wxDoLogSysErrorUtf8(const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogSysError(format, argptr);
+ va_end(argptr);
+}
+#endif // wxUSE_UNICODE_UTF8
void WXDLLEXPORT wxVLogSysError(long err, const wxString& format, va_list argptr)
{
}
}
-void WXDLLEXPORT wxDoLogSysError(long lErrCode, const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void WXDLLEXPORT wxDoLogSysErrorWchar(long lErrCode, const wxChar *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogSysError(lErrCode, format, argptr);
+ va_end(argptr);
+}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void WXDLLEXPORT wxDoLogSysErrorUtf8(long lErrCode, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogSysError(lErrCode, format, argptr);
va_end(argptr);
}
+#endif // wxUSE_UNICODE_UTF8
#ifdef __WATCOMC__
// workaround for http://bugzilla.openwatcom.org/show_bug.cgi?id=351
-void WXDLLEXPORT wxDoLogSysError(unsigned long lErrCode, const wxString& format, ...)
+void WXDLLEXPORT wxDoLogSysError(unsigned long lErrCode, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
}
-void WXDLLEXPORT wxVLogSysError(unsigned long err, const wxString& format, va_list argptr)
+void WXDLLEXPORT wxVLogSysError(unsigned long err, const wxChar *format, va_list argptr)
{ wxVLogSysError((long)err, format, argptr); }
#endif // __WATCOMC__
// wxFileTypeInfo
// ----------------------------------------------------------------------------
-void wxFileTypeInfo::VarArgInit(const wxString& mimeType,
- const wxString& openCmd,
- const wxString& printCmd,
- const wxString& desc,
- ...)
+void wxFileTypeInfo::DoVarArgInit(const wxString& mimeType,
+ const wxString& openCmd,
+ const wxString& printCmd,
+ const wxString& desc,
+ va_list argptr)
{
- va_list argptr;
- va_start(argptr, desc);
-
m_mimeType = mimeType;
m_openCmd = openCmd;
m_printCmd = printCmd;
m_exts.Add(ext.GetString());
}
+}
+
+// NB: DoVarArgInit uses WX_VA_ARG_STRING macro to extract the string and this
+// macro interprets the argument as char* or wchar_t* depending on build
+// (and in UTF8 build, on the current locale). Because only one of the
+// vararg forms below is called and the decision about which one gets
+// called depends on the same conditions WX_VA_ARG_STRING uses, we can
+// implement both of them in the exact same way:
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxFileTypeInfo::VarArgInitWchar(const wxChar *mimeType,
+ const wxChar *openCmd,
+ const wxChar *printCmd,
+ const wxChar *desc,
+ ...)
+{
+ va_list argptr;
+ va_start(argptr, desc);
+
+ DoVarArgInit(mimeType, openCmd, printCmd, desc, argptr);
+
+ va_end(argptr);
+}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxFileTypeInfo::VarArgInitUtf8(const char *mimeType,
+ const char *openCmd,
+ const char *printCmd,
+ const char *desc,
+ ...)
+{
+ va_list argptr;
+ va_start(argptr, desc);
+
+ DoVarArgInit(mimeType, openCmd, printCmd, desc, argptr);
va_end(argptr);
}
+#endif // wxUSE_UNICODE_UTF8
wxFileTypeInfo::wxFileTypeInfo(const wxArrayString& sArray)
return old;
}
-void wxMessageOutput::DoPrintf(const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxMessageOutput::DoPrintfWchar(const wxChar *format, ...)
{
va_list args;
va_start(args, format);
Output(out);
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxMessageOutput::DoPrintfUtf8(const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+ wxString out;
+
+ out.PrintfV(format, args);
+ va_end(args);
+
+ Output(out);
+}
+#endif // wxUSE_UNICODE_UTF8
// ----------------------------------------------------------------------------
// wxMessageOutputBest
// formatted output
// ---------------------------------------------------------------------------
+#if !wxUSE_UTF8_LOCALE_ONLY
/* static */
#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
-wxString wxStringPrintfMixinBase::DoFormat(const wxString& format, ...)
+wxString wxStringPrintfMixinBase::DoFormat(const wxChar *format, ...)
#else
-wxString wxString::DoFormat(const wxString& format, ...)
+wxString wxString::DoFormatWchar(const wxChar *format, ...)
#endif
{
va_list argptr;
return s;
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+/* static */
+wxString wxString::DoFormatUtf8(const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ wxString s;
+ s.PrintfV(format, argptr);
+
+ va_end(argptr);
+
+ return s;
+}
+#endif // wxUSE_UNICODE_UTF8
/* static */
wxString wxString::FormatV(const wxString& format, va_list argptr)
return s;
}
+#if !wxUSE_UTF8_LOCALE_ONLY
#ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
-int wxStringPrintfMixinBase::DoPrintf(const wxString& format, ...)
+int wxStringPrintfMixinBase::DoPrintfWchar(const wxChar *format, ...)
#else
-int wxString::DoPrintf(const wxString& format, ...)
+int wxString::DoPrintfWchar(const wxChar *format, ...)
#endif
{
va_list argptr;
return iLen;
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+int wxString::DoPrintfUtf8(const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ int iLen = PrintfV(format, argptr);
+
+ va_end(argptr);
+
+ return iLen;
+}
+#endif // wxUSE_UNICODE_UTF8
#if wxUSE_UNICODE_UTF8
template<typename BufferType>
// wrappers to printf and scanf function families
// ----------------------------------------------------------------------------
-int wxDoSprintf(char *str, const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+int wxDoSprintfWchar(char *str, const wxChar *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ int rv = wxVsprintf(str, format, argptr);
+
+ va_end(argptr);
+ return rv;
+}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+int wxDoSprintfUtf8(char *str, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
return rv;
}
+#endif // wxUSE_UNICODE_UTF8
#if wxUSE_UNICODE
-int wxDoSprintf(wchar_t *str, const wxString& format, ...)
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+int wxDoSprintfWchar(wchar_t *str, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
return rv;
}
-#endif
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+int wxDoSprintfUtf8(wchar_t *str, const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ int rv = wxVsprintf(str, format, argptr);
+
+ va_end(argptr);
+ return rv;
+}
+#endif // wxUSE_UNICODE_UTF8
+
+#endif // wxUSE_UNICODE
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+int wxDoSnprintfWchar(char *str, size_t size, const wxChar *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ int rv = wxVsnprintf(str, size, format, argptr);
+
+ va_end(argptr);
+ return rv;
+}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
-int wxDoSnprintf(char *str, size_t size, const wxString& format, ...)
+#if wxUSE_UNICODE_UTF8
+int wxDoSnprintfUtf8(char *str, size_t size, const char *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
return rv;
}
+#endif // wxUSE_UNICODE_UTF8
#if wxUSE_UNICODE
-int wxDoSnprintf(wchar_t *str, size_t size, const wxString& format, ...)
+
+#if !wxUSE_UTF8_LOCALE_ONLY
+int wxDoSnprintfWchar(wchar_t *str, size_t size, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
va_end(argptr);
return rv;
}
-#endif
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+int wxDoSnprintfUtf8(wchar_t *str, size_t size, const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+
+ int rv = wxVsnprintf(str, size, format, argptr);
+
+ va_end(argptr);
+ return rv;
+}
+#endif // wxUSE_UNICODE_UTF8
+
+#endif // wxUSE_UNICODE
#ifdef HAVE_BROKEN_VSNPRINTF_DECL
#endif
#if wxUSE_UNICODE
+
+#if !wxUSE_UTF8_LOCALE_ONLY
static int ConvertStringToBuf(const wxString& s, char *out, size_t outsize)
{
const wxWX2WCbuf buf = s.wc_str();
else
return wxConvLibc.FromWChar(NULL, 0, buf);
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
#if wxUSE_UNICODE_UTF8
static int ConvertStringToBuf(const wxString& s, wchar_t *out, size_t outsize)
// else: not enough space
return len;
}
-#endif
+#endif // wxUSE_UNICODE_UTF8
template<typename T>
static size_t PrintfViaString(T *out, size_t outsize,
}
// print postscript datas via required method (file, stream)
-void wxPostScriptDC::DoPsPrintfFormat(const wxString& fmt, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxPostScriptDC::DoPsPrintfFormatWchar(const wxChar *fmt, ...)
{
va_list argptr;
va_start(argptr, fmt);
PsPrint( wxString::FormatV( fmt, argptr ) );
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxPostScriptDC::DoPsPrintfFormatUtf8(const char *fmt, ...)
+{
+ va_list argptr;
+ va_start(argptr, fmt);
+
+ PsPrint( wxString::FormatV( fmt, argptr ) );
+}
+#endif // wxUSE_UNICODE_UTF8
void wxPostScriptDC::PsPrint( const wxString& str )
{
}
}
-void wxDoLogStatus(wxFrame *pFrame, const wxString& format, ...)
+#if !wxUSE_UTF8_LOCALE_ONLY
+void wxDoLogStatusWchar(wxFrame *pFrame, const wxChar *format, ...)
{
va_list argptr;
va_start(argptr, format);
wxVLogStatus(pFrame, format, argptr);
va_end(argptr);
}
+#endif // !wxUSE_UTF8_LOCALE_ONLY
+
+#if wxUSE_UNICODE_UTF8
+void wxDoLogStatusUtf8(wxFrame *pFrame, const char *format, ...)
+{
+ va_list argptr;
+ va_start(argptr, format);
+ wxVLogStatus(pFrame, format, argptr);
+ va_end(argptr);
+}
+#endif // wxUSE_UNICODE_UTF8
// ----------------------------------------------------------------------------
// wxLogGui implementation (FIXME MT-unsafe)
projects / wxWidgets.git / commitdiff
