added new To/FromWChar() API with more reasonable semantics than old MB2WC/WC2MB; for now both coexist and the change is/should be backwards compatible

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@38541 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/strconv.h

@@ -28,6 +28,9 @@
 
 #if wxUSE_WCHAR_T
 
+// the error value returned by wxMBConv methods
+#define wxCONV_FAILED ((size_t)-1)
+
 // ----------------------------------------------------------------------------
 // wxMBConv (abstract base class for conversions)
 // ----------------------------------------------------------------------------
@@ -35,24 +38,43 @@
 class WXDLLIMPEXP_BASE wxMBConv
 {
 public:
-    // The functions doing actual conversion. On success, the return value is
-    // the length (i.e. the number of characters, not bytes, and not counting
-    // the trailing L'\0') of the converted string. On failure, (size_t)-1 is
-    // returned. In the special case when outputBuf is NULL the return value is
-    // the same one but nothing is written to the buffer.
+    // The functions doing actual conversion from/to narrow to/from wide
+    // character strings.
     //
-    // Note that outLen is the length of the output buffer, not the length of
-    // the input (which is always supposed to be terminated by one or more
-    // NULs, as appropriate for the encoding)!
-    virtual size_t MB2WC(wchar_t *out, const char *in, size_t outLen) const = 0;
-    virtual size_t WC2MB(char *out, const wchar_t *in, size_t outLen) const = 0;
+    // On success, the return value is the length (i.e. the number of
+    // characters, not bytes) of the converted string including any trailing
+    // L'\0' or (possibly multiple) '\0'(s). If the conversion fails or if
+    // there is not enough space for everything, including the trailing NUL
+    // character(s), in the output buffer, (size_t)-1 is returned.
+    //
+    // In the special case when dstLen is 0 (outputBuf may be NULL then) the
+    // return value is the length of the needed buffer but nothing happens
+    // otherwise. If srcLen is -1, the entire string, up to and including the
+    // trailing NUL(s), is converted, otherwise exactly srcLen bytes are.
+    //
+    // Typical usage:
+    //
+    //          size_t dstLen = conv.ToWChar(NULL, 0, src);
+    //          if ( dstLen != wxCONV_FAILED )
+    //              ... handle error ...
+    //          wchar_t *wbuf = new wchar_t[dstLen];
+    //          conv.ToWChar(wbuf, dstLen, src);
+    //
+    virtual size_t ToWChar(wchar_t *dst, size_t dstLen,
+                           const char *src, size_t srcLen = -1) const;
 
-    // MB <-> WC
+    virtual size_t FromWChar(char *dst, size_t dstLen,
+                             const wchar_t *src, size_t srcLen = -1) const;
+
+
+    // Convenience functions for translating NUL-terminated strings: returns
+    // the buffer containing the converted string or NULL pointer if the
+    // conversion failed.
     const wxWCharBuffer cMB2WC(const char *in) const;
     const wxCharBuffer cWC2MB(const wchar_t *in) const;
 
-    // Functions converting strings which may contain embedded NULs and don't
-    // have to be NUL-terminated.
+    // Convenience functions for converting strings which may contain embedded
+    // NULs and don't have to be NUL-terminated.
     //
     // inLen is the length of the buffer including trailing NUL if any: if the
     // last 4 bytes of the buffer are all NULs, these functions are more
@@ -94,6 +116,31 @@ public:
     // anything else is not supported currently and -1 should be returned
     virtual size_t GetMBNulLen() const { return 1; }
 
+    // return the maximal value currently returned by GetMBNulLen() for any
+    // encoding
+    static size_t GetMaxMBNulLen() { return 4 /* for UTF-32 */; }
+
+
+    // The old conversion functions. The existing classes currently mostly
+    // implement these ones but we're in transition to using To/FromWChar()
+    // instead and any new classes should implement just the new functions.
+    // For now, however, we provide default implementation of To/FromWChar() in
+    // this base class in terms of MB2WC/WC2MB() to avoid having to rewrite all
+    // the conversions at once.
+    //
+    // On success, the return value is the length (i.e. the number of
+    // characters, not bytes) not counting the trailing NUL(s) of the converted
+    // string. On failure, (size_t)-1 is returned. In the special case when
+    // outputBuf is NULL the return value is the same one but nothing is
+    // written to the buffer.
+    //
+    // Note that outLen is the length of the output buffer, not the length of
+    // the input (which is always supposed to be terminated by one or more
+    // NULs, as appropriate for the encoding)!
+    virtual size_t MB2WC(wchar_t *out, const char *in, size_t outLen) const = 0;
+    virtual size_t WC2MB(char *out, const wchar_t *in, size_t outLen) const = 0;
+
+
     // virtual dtor for any base class
     virtual ~wxMBConv();
 };