added wxAPPLY and wxCLOSE flags to CreateStdDialogButtonSizer() (Marcin Wojdyr)

[wxWidgets.git] / include / wx / string.h

diff --git a/include/wx/string.h b/include/wx/string.h
index dd56e13c7afdfca876af5dabaae9a41dfd60429a..3bc5588f9ad9bbe42f293634812e00d6981861c9 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -169,7 +169,7 @@ inline int Stricmp(const char *psz1, const char *psz2)
 
 // Lightweight object returned by wxString::c_str() and implicitly convertible
 // to either const char* or const wchar_t*.
 
 // Lightweight object returned by wxString::c_str() and implicitly convertible
 // to either const char* or const wchar_t*.

-class wxCStrData
+class WXDLLIMPEXP_BASE wxCStrData

 {
 private:
     // Ctors; for internal use by wxString and wxCStrData only
 {
 private:
     // Ctors; for internal use by wxString and wxCStrData only


@@ -182,13 +182,22 @@ public:
     wxCStrData(char *buf);
     wxCStrData(wchar_t *buf);
 
     wxCStrData(char *buf);
     wxCStrData(wchar_t *buf);
 

-    ~wxCStrData();
+    inline ~wxCStrData();

 
 

+    // methods defined inline below must be declared inline or mingw32 3.4.5
+    // warns about "<symbol> defined locally after being referenced with
+    // dllimport linkage"
+#if wxUSE_UNICODE_WCHAR
+    inline
+#endif

     const wchar_t* AsWChar() const;
     operator const wchar_t*() const { return AsWChar(); }
 
     const wchar_t* AsWChar() const;
     operator const wchar_t*() const { return AsWChar(); }
 

-    operator bool() const;
+    inline operator bool() const;

 
 

+#if !wxUSE_UNICODE
+    inline
+#endif

     const char* AsChar() const;
     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }
     const char* AsChar() const;
     const unsigned char* AsUnsignedChar() const
         { return (const unsigned char *) AsChar(); }


@@ -197,11 +206,11 @@ public:
 
     operator const void*() const { return AsChar(); }
 
 
     operator const void*() const { return AsChar(); }
 

-    wxString AsString() const;
+    inline wxString AsString() const;

 
     // allow expressions like "c_str()[0]":
 
     // allow expressions like "c_str()[0]":

+    inline wxUniChar operator[](size_t n) const;

     wxUniChar operator[](int n) const { return operator[](size_t(n)); }
     wxUniChar operator[](int n) const { return operator[](size_t(n)); }

-    wxUniChar operator[](size_t n) const;

     wxUniChar operator[](long n) const { return operator[](size_t(n)); }
 #ifndef wxSIZE_T_IS_UINT
     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }
     wxUniChar operator[](long n) const { return operator[](size_t(n)); }
 #ifndef wxSIZE_T_IS_UINT
     wxUniChar operator[](unsigned int n) const { return operator[](size_t(n)); }


@@ -239,7 +248,7 @@ public:
 
     // this operator is needed to make expressions like "*c_str()" or
     // "*(c_str() + 2)" work
 
     // this operator is needed to make expressions like "*c_str()" or
     // "*(c_str() + 2)" work

-    wxUniChar operator*() const;
+    inline wxUniChar operator*() const;

 
 private:
     const wxString *m_str;
 
 private:
     const wxString *m_str;


@@ -362,13 +371,14 @@ private:
       T data;
       size_t len;
 
       T data;
       size_t len;
 

-      SubstrBufFromType() {}

       SubstrBufFromType(const T& data_, size_t len_)
           : data(data_), len(len_) {}
   };
 
 #if wxUSE_UNICODE_UTF8
       SubstrBufFromType(const T& data_, size_t len_)
           : data(data_), len(len_) {}
   };
 
 #if wxUSE_UNICODE_UTF8

-  // FIXME-UTF8: this will have to use slightly different type
+  // even char* -> char* needs conversion, from locale charset to UTF-8
+  typedef SubstrBufFromType<wxCharBuffer>    SubstrBufFromWC;
+  typedef SubstrBufFromType<wxCharBuffer>    SubstrBufFromMB;

 #elif wxUSE_UNICODE_WCHAR
   typedef SubstrBufFromType<const wchar_t*>  SubstrBufFromWC;
   typedef SubstrBufFromType<wxWCharBuffer>   SubstrBufFromMB;
 #elif wxUSE_UNICODE_WCHAR
   typedef SubstrBufFromType<const wchar_t*>  SubstrBufFromWC;
   typedef SubstrBufFromType<wxWCharBuffer>   SubstrBufFromMB;


@@ -383,8 +393,12 @@ private:
   // between UTF-8 and wchar_t* representations of the string are mostly
   // contained here.
 
   // between UTF-8 and wchar_t* representations of the string are mostly
   // contained here.
 

-#if wxUSE_UNICODE
-  // FIXME-UTF8: This will need changes when UTF8 build is introduced
+#if wxUSE_UNICODE_UTF8
+  static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength,
+                                    const wxMBConv& conv);
+  static SubstrBufFromWC ConvertStr(const wchar_t *pwz, size_t nLength,
+                                    const wxMBConv& conv);
+#elif wxUSE_UNICODE_WCHAR

   static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength,
                                     const wxMBConv& conv);
 #else
   static SubstrBufFromMB ConvertStr(const char *psz, size_t nLength,
                                     const wxMBConv& conv);
 #else


@@ -438,6 +452,7 @@ private:
   // encodes the character to a form used to represent it in internal
   // representation (returns a string in UTF8 version)
   static wxChar EncodeChar(wxUniChar ch) { return (wxChar)ch; }
   // encodes the character to a form used to represent it in internal
   // representation (returns a string in UTF8 version)
   static wxChar EncodeChar(wxUniChar ch) { return (wxChar)ch; }

+  static wxUniChar DecodeChar(wxStringImpl::const_iterator i) { return *i; }

 
   // translates position index in wxString to/from index in underlying
   // wxStringImpl:
 
   // translates position index in wxString to/from index in underlying
   // wxStringImpl:


@@ -450,11 +465,56 @@ private:
 
 #else // wxUSE_UNICODE_UTF8
 
 
 #else // wxUSE_UNICODE_UTF8
 

-  typedef char Utf8CharBuffer[5];
+  // checks correctness of UTF-8 sequence
+  static bool IsValidUtf8String(const char *c);
+#ifdef __WXDEBUG__
+  static bool IsValidUtf8LeadByte(unsigned char c);
+#endif
+
+  // table of offsets to skip forward when iterating
+  static unsigned char ms_utf8IterTable[256];
+
+  static void IncIter(wxStringImpl::iterator& i)
+  {
+      wxASSERT( IsValidUtf8LeadByte(*i) );
+      i += ms_utf8IterTable[(unsigned char)*i];
+  }
+  static void IncIter(wxStringImpl::const_iterator& i)
+  {
+      wxASSERT( IsValidUtf8LeadByte(*i) );
+      i += ms_utf8IterTable[(unsigned char)*i];
+  }
+
+  static void DecIter(wxStringImpl::iterator& i);
+  static void DecIter(wxStringImpl::const_iterator& i);
+  static wxStringImpl::iterator AddToIter(wxStringImpl::iterator i, int n);
+  static wxStringImpl::const_iterator AddToIter(wxStringImpl::const_iterator i, int n);
+  static int DiffIters(wxStringImpl::const_iterator i1, wxStringImpl::const_iterator i2);
+  static int DiffIters(wxStringImpl::iterator i1, wxStringImpl::iterator i2);
+
+  struct Utf8CharBuffer
+  {
+      char data[5];
+      operator const char*() const { return data; }
+  };

   static Utf8CharBuffer EncodeChar(wxUniChar ch);
   // returns n copies of ch encoded in UTF-8 string
   static wxCharBuffer EncodeNChars(size_t n, wxUniChar ch);
 
   static Utf8CharBuffer EncodeChar(wxUniChar ch);
   // returns n copies of ch encoded in UTF-8 string
   static wxCharBuffer EncodeNChars(size_t n, wxUniChar ch);
 

+  // returns the length of UTF-8 encoding of the character with lead byte 'c'
+  static size_t GetUtf8CharLength(char c)
+  {
+      wxASSERT( IsValidUtf8LeadByte(c) );
+      return ms_utf8IterTable[(unsigned char)c];
+  }
+
+  // decodes single UTF-8 character from UTF-8 string
+  // FIXME-UTF8: move EncodeChar/DecodeChar and other operations to separate
+  //             class
+  static wxUniChar DecodeChar(wxStringImpl::const_iterator i)
+    { return wxUniCharRef::DecodeChar(i); }
+  friend class WXDLLIMPEXP_BASE wxUniCharRef;
+

   size_t PosToImpl(size_t pos) const
   {
       if ( pos == 0 || pos == npos )
   size_t PosToImpl(size_t pos) const
   {
       if ( pos == 0 || pos == npos )


@@ -463,6 +523,15 @@ private:
           return wxStringImpl::const_iterator(begin() + pos) - m_impl.begin();
   }
 
           return wxStringImpl::const_iterator(begin() + pos) - m_impl.begin();
   }
 

+  void PosLenToImpl(size_t pos, size_t len, size_t *implPos, size_t *implLen) const;
+
+  size_t LenToImpl(size_t len) const
+  {
+      size_t pos, len2;
+      PosLenToImpl(0, len, &pos, &len2);
+      return len2;
+  }
+

   size_t PosFromImpl(size_t pos) const
   {
       if ( pos == 0 || pos == npos )
   size_t PosFromImpl(size_t pos) const
   {
       if ( pos == 0 || pos == npos )


@@ -471,13 +540,23 @@ private:
           return const_iterator(m_impl.begin() + pos) - begin();
   }
 
           return const_iterator(m_impl.begin() + pos) - begin();
   }
 

-  // FIXME: return as-is without copying under UTF8 locale, return
-  //        converted string under other locales - needs wxCharBuffer
-  //        changes
-  static wxCharBuffer ImplStr(const char* str);
+  size_t IterToImplPos(wxStringImpl::iterator i) const
+    { return wxStringImpl::const_iterator(i) - m_impl.begin(); }
+
+  // FIXME-UTF8: return as-is without copying under UTF8 locale, return
+  //             converted string under other locales - needs wxCharBuffer
+  //             changes
+  static wxCharBuffer ImplStr(const char* str,
+                              const wxMBConv& conv = wxConvLibc)
+    { return ConvertStr(str, npos, conv).data; }
+  static SubstrBufFromMB ImplStr(const char* str, size_t n,
+                                 const wxMBConv& conv = wxConvLibc)
+    { return ConvertStr(str, n, conv); }

 
   static wxCharBuffer ImplStr(const wchar_t* str)
 
   static wxCharBuffer ImplStr(const wchar_t* str)

-      { return wxConvUTF8.cWC2MB(str); }
+    { return ConvertStr(str, npos, wxConvUTF8).data; }
+  static SubstrBufFromWC ImplStr(const wchar_t* str, size_t n)
+    { return ConvertStr(str, n, wxConvUTF8); }

 #endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
 
 
 #endif // !wxUSE_UNICODE_UTF8/wxUSE_UNICODE_UTF8
 
 


@@ -487,7 +566,9 @@ public:
   wxString() {}
 
     // copy ctor
   wxString() {}
 
     // copy ctor

+  // FIXME-UTF8: this one needs to do UTF-8 conversion in UTF-8 build!

   wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { }
   wxString(const wxStringImpl& stringSrc) : m_impl(stringSrc) { }

+

   wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { }
 
     // string containing nRepeat copies of ch
   wxString(const wxString& stringSrc) : m_impl(stringSrc.m_impl) { }
 
     // string containing nRepeat copies of ch


@@ -562,7 +643,17 @@ public:
   wxString(const wxString& str, size_t nLength)
       : m_impl(str.Mid(0, nLength).m_impl) {}
 
   wxString(const wxString& str, size_t nLength)
       : m_impl(str.Mid(0, nLength).m_impl) {}
 

-  ~wxString();
+  // even if we're not built with wxUSE_STL == 1 it is very convenient to allow
+  // implicit conversions from std::string to wxString as this allows to use
+  // the same strings in non-GUI and GUI code, however we don't want to
+  // unconditionally add this ctor as it would make wx lib dependent on
+  // libstdc++ on some Linux versions which is bad, so instead we ask the
+  // client code to define this wxUSE_STD_STRING symbol if they need it
+#if wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING
+  wxString(const wxStdString& s)
+      // FIXME-UTF8: this one needs to do UTF-8 conversion in UTF-8 build!
+      : m_impl(s.c_str()) { } // FIXME-UTF8: this is broken for embedded 0s
+#endif // wxUSE_STD_STRING && !wxUSE_STL_BASED_WXSTRING

 
 public:
   // standard types
 
 public:
   // standard types


@@ -576,7 +667,12 @@ public:
   typedef wxUniChar const_reference;
 
 #if wxUSE_STL
   typedef wxUniChar const_reference;
 
 #if wxUSE_STL

-  #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
+  #if wxUSE_UNICODE_UTF8
+    // random access is not O(1), as required by Random Access Iterator
+    #define WX_STR_ITERATOR_TAG std::bidirectional_iterator_tag
+  #else
+    #define WX_STR_ITERATOR_TAG std::random_access_iterator_tag
+  #endif

 #else
   #define WX_STR_ITERATOR_TAG void /* dummy type */
 #endif
 #else
   #define WX_STR_ITERATOR_TAG void /* dummy type */
 #endif


@@ -592,8 +688,6 @@ public:
           typedef reference_type reference;                                 \
           typedef pointer_type pointer;                                     \
                                                                             \
           typedef reference_type reference;                                 \
           typedef pointer_type pointer;                                     \
                                                                             \

-          iterator_name(const iterator_name& i) : m_cur(i.m_cur) {}         \
-                                                                            \

           reference operator*() const { return reference_ctor; }            \
           reference operator[](size_t n) const { return *(*this + n); }     \
                                                                             \
           reference operator*() const { return reference_ctor; }            \
           reference operator[](size_t n) const { return *(*this + n); }     \
                                                                             \


@@ -614,24 +708,16 @@ public:
               return tmp;                                                   \
           }                                                                 \
                                                                             \
               return tmp;                                                   \
           }                                                                 \
                                                                             \

-          iterator_name operator+(int n) const                              \
-            { return iterator_name(wxString::AddToIter(m_cur, n)); }        \
-          iterator_name operator+(size_t n) const                           \
-            { return iterator_name(wxString::AddToIter(m_cur, (int)n)); }   \
-          iterator_name operator-(int n) const                              \
-            { return iterator_name(wxString::AddToIter(m_cur, -n)); }       \
-          iterator_name operator-(size_t n) const                           \
-            { return iterator_name(wxString::AddToIter(m_cur, -(int)n)); }  \
-          iterator_name operator+=(int n)                                   \
+          iterator_name& operator+=(int n)                                  \

             { m_cur = wxString::AddToIter(m_cur, n); return *this; }        \
             { m_cur = wxString::AddToIter(m_cur, n); return *this; }        \

-          iterator_name operator+=(size_t n)                                \
+          iterator_name& operator+=(size_t n)                               \

             { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; }   \
             { m_cur = wxString::AddToIter(m_cur, (int)n); return *this; }   \

-          iterator_name operator-=(int n)                                   \
+          iterator_name& operator-=(int n)                                  \

             { m_cur = wxString::AddToIter(m_cur, -n); return *this; }       \
             { m_cur = wxString::AddToIter(m_cur, -n); return *this; }       \

-          iterator_name operator-=(size_t n)                                \
+          iterator_name& operator-=(size_t n)                               \

             { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; }  \
                                                                             \
             { m_cur = wxString::AddToIter(m_cur, -(int)n); return *this; }  \
                                                                             \

-          unsigned operator-(const iterator_name& i) const                  \
+          difference_type operator-(const iterator_name& i) const           \

             { return wxString::DiffIters(m_cur, i.m_cur); }                 \
                                                                             \
           bool operator==(const iterator_name& i) const                     \
             { return wxString::DiffIters(m_cur, i.m_cur); }                 \
                                                                             \
           bool operator==(const iterator_name& i) const                     \


@@ -650,34 +736,100 @@ public:
                                                                             \
       private:                                                              \
           /* for internal wxString use only: */                             \
                                                                             \
       private:                                                              \
           /* for internal wxString use only: */                             \

-          iterator_name(underlying_iterator ptr) : m_cur(ptr) {}            \

           operator underlying_iterator() const { return m_cur; }            \
                                                                             \
           friend class WXDLLIMPEXP_BASE wxString;                           \
           friend class WXDLLIMPEXP_BASE wxCStrData;                         \
                                                                             \
       private:                                                              \
           operator underlying_iterator() const { return m_cur; }            \
                                                                             \
           friend class WXDLLIMPEXP_BASE wxString;                           \
           friend class WXDLLIMPEXP_BASE wxCStrData;                         \
                                                                             \
       private:                                                              \

-          underlying_iterator m_cur;
+          underlying_iterator m_cur

 
   class const_iterator;
 
 
   class const_iterator;
 

+#if wxUSE_UNICODE_UTF8
+  class iterator
+  {
+      // NB: In UTF-8 build, (non-const) iterator needs to keep reference
+      //     to the underlying wxStringImpl, because UTF-8 is variable-length
+      //     encoding and changing the value pointer to by an iterator using
+      //     its operator* requires calling wxStringImpl::replace() if the old
+      //     and new values differ in their encoding's length.
+
+      WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,
+                           wxUniCharRef::CreateForString(m_str, m_cur));
+
+  public:
+      iterator(const iterator& i) : m_cur(i.m_cur), m_str(i.m_str) {}
+
+      iterator operator+(int n) const
+        { return iterator(m_str, wxString::AddToIter(m_cur, n)); }
+      iterator operator+(size_t n) const
+        { return iterator(m_str, wxString::AddToIter(m_cur, (int)n)); }
+      iterator operator-(int n) const
+        { return iterator(m_str, wxString::AddToIter(m_cur, -n)); }
+      iterator operator-(size_t n) const
+        { return iterator(m_str, wxString::AddToIter(m_cur, -(int)n)); }
+
+  private:
+      iterator(wxString *str, underlying_iterator ptr)
+          : m_cur(ptr), m_str(str->m_impl) {}
+      iterator(wxStringImpl& str, underlying_iterator ptr)
+          : m_cur(ptr), m_str(str) {}
+
+      wxStringImpl& m_str;
+
+      friend class const_iterator;
+  };
+#else // !wxUSE_UNICODE_UTF8

   class iterator
   {
       WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,
   class iterator
   {
       WX_STR_ITERATOR_IMPL(iterator, wxChar*, wxUniCharRef,

-                           wxUniCharRef::CreateForString(m_cur))
+                           wxUniCharRef::CreateForString(m_cur));
+
+  public:
+      iterator(const iterator& i) : m_cur(i.m_cur) {}
+
+      iterator operator+(int n) const
+        { return iterator(wxString::AddToIter(m_cur, n)); }
+      iterator operator+(size_t n) const
+        { return iterator(wxString::AddToIter(m_cur, (int)n)); }
+      iterator operator-(int n) const
+        { return iterator(wxString::AddToIter(m_cur, -n)); }
+      iterator operator-(size_t n) const
+        { return iterator(wxString::AddToIter(m_cur, -(int)n)); }
+
+  private:
+      // for internal wxString use only:
+      iterator(underlying_iterator ptr) : m_cur(ptr) {}
+      iterator(wxString *WXUNUSED(str), underlying_iterator ptr) : m_cur(ptr) {}

 
       friend class const_iterator;
   };
 
       friend class const_iterator;
   };

+#endif // wxUSE_UNICODE_UTF8/!wxUSE_UNICODE_UTF8

 
   class const_iterator
   {
       // NB: reference_type is intentionally value, not reference, the character
       //     may be encoded differently in wxString data:
       WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar,
 
   class const_iterator
   {
       // NB: reference_type is intentionally value, not reference, the character
       //     may be encoded differently in wxString data:
       WX_STR_ITERATOR_IMPL(const_iterator, const wxChar*, wxUniChar,

-                           wxUniChar(*m_cur))
+                           wxString::DecodeChar(m_cur));

 
   public:
 
   public:

+      const_iterator(const const_iterator& i) : m_cur(i.m_cur) {}

       const_iterator(const iterator& i) : m_cur(i.m_cur) {}
       const_iterator(const iterator& i) : m_cur(i.m_cur) {}

+
+      const_iterator operator+(int n) const
+        { return const_iterator(wxString::AddToIter(m_cur, n)); }
+      const_iterator operator+(size_t n) const
+        { return const_iterator(wxString::AddToIter(m_cur, (int)n)); }
+      const_iterator operator-(int n) const
+        { return const_iterator(wxString::AddToIter(m_cur, -n)); }
+      const_iterator operator-(size_t n) const
+        { return const_iterator(wxString::AddToIter(m_cur, -(int)n)); }
+
+  private:
+      // for internal wxString use only:
+      const_iterator(underlying_iterator ptr) : m_cur(ptr) {}

   };
 
   #undef WX_STR_ITERATOR_TAG
   };
 
   #undef WX_STR_ITERATOR_TAG


@@ -760,10 +912,10 @@ public:
 
   // first valid index position
   const_iterator begin() const { return const_iterator(m_impl.begin()); }
 
   // first valid index position
   const_iterator begin() const { return const_iterator(m_impl.begin()); }

-  iterator begin() { return iterator(m_impl.begin()); }
+  iterator begin() { return iterator(this, m_impl.begin()); }

   // position one after the last valid one
   const_iterator end() const { return const_iterator(m_impl.end()); }
   // position one after the last valid one
   const_iterator end() const { return const_iterator(m_impl.end()); }

-  iterator end() { return iterator(m_impl.end()); }
+  iterator end() { return iterator(this, m_impl.end()); }

 
   // first element of the reversed string
   const_reverse_iterator rbegin() const
 
   // first element of the reversed string
   const_reverse_iterator rbegin() const


@@ -918,7 +1070,7 @@ public:
 
     // explicit conversion to C string in internal representation (char*,
     // wchar_t*, UTF-8-encoded char*, depending on the build):
 
     // explicit conversion to C string in internal representation (char*,
     // wchar_t*, UTF-8-encoded char*, depending on the build):

-    const_pointer wx_str() const { return m_impl.c_str(); }
+    const wxStringCharType *wx_str() const { return m_impl.c_str(); }

 
     // conversion to *non-const* multibyte or widestring buffer; modifying
     // returned buffer won't affect the string, these methods are only useful
 
     // conversion to *non-const* multibyte or widestring buffer; modifying
     // returned buffer won't affect the string, these methods are only useful


@@ -956,21 +1108,26 @@ public:
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 
 
     const wxWX2MBbuf mbc_str() const { return mb_str(*wxConvCurrent); }
 

-    const wxChar* wc_str() const { return c_str(); }
-
+#if wxUSE_UNICODE_WCHAR
+    const wxChar* wc_str() const { return wx_str(); }
+#elif wxUSE_UNICODE_UTF8
+    const wxWCharBuffer wc_str() const;
+#endif

     // for compatibility with !wxUSE_UNICODE version
     // for compatibility with !wxUSE_UNICODE version

-    const wxChar* wc_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+    const wxWX2WCbuf wc_str(const wxMBConv& WXUNUSED(conv)) const
+      { return wc_str(); }

 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 #else // !wxMBFILES
 
 #if wxMBFILES
     const wxCharBuffer fn_str() const { return mb_str(wxConvFile); }
 #else // !wxMBFILES

-    const wxChar* fn_str() const { return c_str(); }
+    const wxWX2WCbuf fn_str() const { return wc_str(); }

 #endif // wxMBFILES/!wxMBFILES
 #endif // wxMBFILES/!wxMBFILES

+

 #else // ANSI
 #else // ANSI

-    const wxChar* mb_str() const { return c_str(); }
+    const wxChar* mb_str() const { return wx_str(); }

 
     // for compatibility with wxUSE_UNICODE version
 
     // for compatibility with wxUSE_UNICODE version

-    const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return c_str(); }
+    const wxChar* mb_str(const wxMBConv& WXUNUSED(conv)) const { return wx_str(); }

 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 
 
     const wxWX2MBbuf mbc_str() const { return mb_str(); }
 


@@ -1581,14 +1738,25 @@ public:
   {
 #if wxUSE_UNICODE_UTF8
     if ( !ch.IsAscii() )
   {
 #if wxUSE_UNICODE_UTF8
     if ( !ch.IsAscii() )

-        m_impl.insert(begin() + nPos, EncodeNChars(n, ch));
+        m_impl.insert(PosToImpl(nPos), EncodeNChars(n, ch));

     else
 #endif
     else
 #endif

-        m_impl.insert(begin() + nPos, n, (wxStringCharType)ch);
+        m_impl.insert(PosToImpl(nPos), n, (wxStringCharType)ch);

     return *this;
   }
   iterator insert(iterator it, wxUniChar ch)
     return *this;
   }
   iterator insert(iterator it, wxUniChar ch)

-    { return iterator(m_impl.insert(it, EncodeChar(ch))); }
+  {
+#if wxUSE_UNICODE_UTF8
+    if ( !ch.IsAscii() )
+    {
+        size_t pos = IterToImplPos(it);
+        m_impl.insert(pos, EncodeChar(ch));
+        return iterator(this, m_impl.begin() + pos);
+    }
+    else
+#endif
+        return iterator(this, m_impl.insert(it, (wxStringCharType)ch));
+  }

   void insert(iterator it, const_iterator first, const_iterator last)
     { m_impl.insert(it, first, last); }
   void insert(iterator it, const char *first, const char *last)
   void insert(iterator it, const_iterator first, const_iterator last)
     { m_impl.insert(it, first, last); }
   void insert(iterator it, const char *first, const char *last)


@@ -1599,7 +1767,7 @@ public:
   {
 #if wxUSE_UNICODE_UTF8
     if ( !ch.IsAscii() )
   {
 #if wxUSE_UNICODE_UTF8
     if ( !ch.IsAscii() )

-        m_impl.insert(it, EncodeNChars(n, ch));
+        m_impl.insert(IterToImplPos(it), EncodeNChars(n, ch));

     else
 #endif
         m_impl.insert(it, n, (wxStringCharType)ch);
     else
 #endif
         m_impl.insert(it, n, (wxStringCharType)ch);


@@ -1615,9 +1783,9 @@ public:
   }
     // delete characters from first up to last
   iterator erase(iterator first, iterator last)
   }
     // delete characters from first up to last
   iterator erase(iterator first, iterator last)

-    { return iterator(m_impl.erase(first, last)); }
+    { return iterator(this, m_impl.erase(first, last)); }

   iterator erase(iterator first)
   iterator erase(iterator first)

-    { return iterator(m_impl.erase(first)); }
+    { return iterator(this, m_impl.erase(first)); }

 
 #ifdef wxSTRING_BASE_HASNT_CLEAR
   void clear() { erase(); }
 
 #ifdef wxSTRING_BASE_HASNT_CLEAR
   void clear() { erase(); }


@@ -1867,7 +2035,11 @@ public:
 
     // as strpbrk() but starts at nStart, returns npos if not found
   size_t find_first_of(const wxString& str, size_t nStart = 0) const
 
     // as strpbrk() but starts at nStart, returns npos if not found
   size_t find_first_of(const wxString& str, size_t nStart = 0) const

+#if wxUSE_UNICODE // FIXME-UTF8: temporary
+    { return find_first_of(str.mb_str().data(), nStart); }
+#else

     { return find_first_of((const wxChar*)str.c_str(), nStart); }
     { return find_first_of((const wxChar*)str.c_str(), nStart); }

+#endif

     // same as above
   size_t find_first_of(const char* sz, size_t nStart = 0) const;
   size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const;
     // same as above
   size_t find_first_of(const char* sz, size_t nStart = 0) const;
   size_t find_first_of(const wchar_t* sz, size_t nStart = 0) const;


@@ -1878,7 +2050,11 @@ public:
     { return find(c, nStart); }
     // find the last (starting from nStart) char from str in this string
   size_t find_last_of (const wxString& str, size_t nStart = npos) const
     { return find(c, nStart); }
     // find the last (starting from nStart) char from str in this string
   size_t find_last_of (const wxString& str, size_t nStart = npos) const

+#if wxUSE_UNICODE // FIXME-UTF8: temporary
+    { return find_last_of(str.mb_str().data(), nStart); }
+#else

     { return find_last_of((const wxChar*)str.c_str(), nStart); }
     { return find_last_of((const wxChar*)str.c_str(), nStart); }

+#endif

     // same as above
   size_t find_last_of (const char* sz, size_t nStart = npos) const;
   size_t find_last_of (const wchar_t* sz, size_t nStart = npos) const;
     // same as above
   size_t find_last_of (const char* sz, size_t nStart = npos) const;
   size_t find_last_of (const wchar_t* sz, size_t nStart = npos) const;


@@ -1892,7 +2068,11 @@ public:
 
     // as strspn() (starting from nStart), returns npos on failure
   size_t find_first_not_of(const wxString& str, size_t nStart = 0) const
 
     // as strspn() (starting from nStart), returns npos on failure
   size_t find_first_not_of(const wxString& str, size_t nStart = 0) const

+#if wxUSE_UNICODE // FIXME-UTF8: temporary
+    { return find_first_not_of(str.mb_str().data(), nStart); }
+#else

     { return find_first_not_of((const wxChar*)str.c_str(), nStart); }
     { return find_first_not_of((const wxChar*)str.c_str(), nStart); }

+#endif

     // same as above
   size_t find_first_not_of(const char* sz, size_t nStart = 0) const;
   size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const;
     // same as above
   size_t find_first_not_of(const char* sz, size_t nStart = 0) const;
   size_t find_first_not_of(const wchar_t* sz, size_t nStart = 0) const;


@@ -1902,7 +2082,11 @@ public:
   size_t find_first_not_of(wxUniChar ch, size_t nStart = 0) const;
     //  as strcspn()
   size_t find_last_not_of(const wxString& str, size_t nStart = npos) const
   size_t find_first_not_of(wxUniChar ch, size_t nStart = 0) const;
     //  as strcspn()
   size_t find_last_not_of(const wxString& str, size_t nStart = npos) const

+#if wxUSE_UNICODE // FIXME-UTF8: temporary
+    { return find_last_not_of(str.mb_str().data(), nStart); }
+#else

     { return find_last_not_of((const wxChar*)str.c_str(), nStart); }
     { return find_last_not_of((const wxChar*)str.c_str(), nStart); }

+#endif

     // same as above
   size_t find_last_not_of(const char* sz, size_t nStart = npos) const;
   size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const;
     // same as above
   size_t find_last_not_of(const char* sz, size_t nStart = npos) const;
   size_t find_last_not_of(const wchar_t* sz, size_t nStart = npos) const;


@@ -1992,6 +2176,35 @@ private:
 
 private:
   wxStringImpl m_impl;
 
 private:
   wxStringImpl m_impl;

+
+  // buffers for compatibility conversion from (char*)c_str() and
+  // (wchar_t*)c_str():
+  // FIXME-UTF8: bechmark various approaches to keeping compatibility buffers
+  template<typename T>
+  struct ConvertedBuffer
+  {
+      ConvertedBuffer() : m_buf(NULL) {}
+      ~ConvertedBuffer()
+          { free(m_buf); }
+
+      operator T*() const { return m_buf; }
+
+      ConvertedBuffer& operator=(T *str)
+      {
+          free(m_buf);
+          m_buf = str;
+          return *this;
+      }
+
+      T *m_buf;
+  };
+#if wxUSE_UNICODE
+  ConvertedBuffer<char> m_convertedToChar;
+#endif
+#if !wxUSE_UNICODE_WCHAR
+  ConvertedBuffer<wchar_t> m_convertedToWChar;
+#endif
+  friend class WXDLLIMPEXP_BASE wxCStrData;

 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN
 };
 
 #ifdef wxNEEDS_WXSTRING_PRINTF_MIXIN


@@ -2299,7 +2512,7 @@ inline wxCStrData::~wxCStrData()
 inline wxCStrData::operator bool() const
 {
     return !m_str->empty();
 inline wxCStrData::operator bool() const
 {
     return !m_str->empty();

-};
+}

 
 // simple cases for AsChar() and AsWChar(), the complicated ones are
 // in string.cpp
 
 // simple cases for AsChar() and AsWChar(), the complicated ones are
 // in string.cpp


@@ -2338,6 +2551,22 @@ inline wxUniChar wxCStrData::operator[](size_t n) const
     return m_str->at(m_offset + n);
 }
 
     return m_str->at(m_offset + n);
 }
 

+// ----------------------------------------------------------------------------
+// more wxCStrData operators
+// ----------------------------------------------------------------------------
+
+// we need to define those to allow "size_t pos = p - s.c_str()" where p is
+// some pointer into the string
+inline size_t operator-(const char *p, const wxCStrData& cs)
+{
+    return p - cs.AsChar();
+}
+
+inline size_t operator-(const wchar_t *p, const wxCStrData& cs)
+{
+    return p - cs.AsWChar();
+}
+

 // ----------------------------------------------------------------------------
 // implementation of wx[W]CharBuffer inline methods using wxCStrData
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // implementation of wx[W]CharBuffer inline methods using wxCStrData
 // ----------------------------------------------------------------------------