Implemented wxButton::DoGetBestSize for wxMotif. Now normal buttons

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

diff --git a/include/wx/string.h b/include/wx/string.h
index 4f6d342f9e1b32fe44621cea31f945e4cc69eb8b..c9169837c7e0494cd48885ddf23e75aabf072df6 100644 (file)
--- a/include/wx/string.h
+++ b/include/wx/string.h
@@ -18,7 +18,7 @@
 #ifndef _WX_WXSTRINGH__
 #define _WX_WXSTRINGH__
 
 #ifndef _WX_WXSTRINGH__
 #define _WX_WXSTRINGH__
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)

     #pragma interface "string.h"
 #endif
 
     #pragma interface "string.h"
 #endif
 


@@ -29,15 +29,12 @@
 // compile the std::string compatibility functions if defined
 #define   wxSTD_STRING_COMPATIBILITY
 
 // compile the std::string compatibility functions if defined
 #define   wxSTD_STRING_COMPATIBILITY
 

-// define to derive wxString from wxObject (deprecated!)
-#ifdef WXSTRING_IS_WXOBJECT
-    #undef WXSTRING_IS_WXOBJECT
-#endif
-

 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // headers
 // ----------------------------------------------------------------------------
 

+#include "wx/defs.h"        // everybody should include this
+

 #if defined(__WXMAC__) || defined(__VISAGECPP__)
     #include <ctype.h>
 #endif
 #if defined(__WXMAC__) || defined(__VISAGECPP__)
     #include <ctype.h>
 #endif


@@ -63,31 +60,26 @@
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()
 
 #ifdef HAVE_STRINGS_H
     #include <strings.h>    // for strcasecmp()

-#endif // AIX
+#endif // HAVE_STRINGS_H

 
 

-#include "wx/defs.h"        // everybody should include this

 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 
 #include "wx/wxchar.h"      // for wxChar
 #include "wx/buffer.h"      // for wxCharBuffer
 #include "wx/strconv.h"     // for wxConvertXXX() macros and wxMBConv classes
 

-#ifndef  WX_PRECOMP
-  #ifdef    WXSTRING_IS_WXOBJECT
-    #include "wx/object.h" // base class
-  #endif
-#endif // !PCH
-

 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 // macros
 // ---------------------------------------------------------------------------
 

-// 'naughty' cast
+// casts [unfortunately!] needed to call some broken functions which require
+// "char *" instead of "const char *"

 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxMBSTRINGCAST (char *)(const char *)
 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only
 #define   WXSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxCSTRINGCAST (wxChar *)(const wxChar *)
 #define   wxMBSTRINGCAST (char *)(const char *)
 #define   wxWCSTRINGCAST (wchar_t *)(const wchar_t *)
 
 // implementation only

-#define   ASSERT_VALID_INDEX(i) wxASSERT( (unsigned)(i) <= Len() )
+#define   wxASSERT_VALID_INDEX(i) \
+    wxASSERT_MSG( (size_t)(i) <= Len(), _T("invalid index in wxString") )

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -139,6 +131,8 @@ inline int Stricmp(const char *psz1, const char *psz2)
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);
   return stricmp(psz1, psz2);
 #elif defined(__WATCOMC__)
   return stricmp(psz1, psz2);

+#elif defined(__DJGPP__)
+  return stricmp(psz1, psz2);

 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)
 #elif defined(__EMX__)
   return stricmp(psz1, psz2);
 #elif defined(__WXPM__)


@@ -171,15 +165,6 @@ inline int Stricmp(const char *psz1, const char *psz2)
 #endif  // OS/compiler
 }
 
 #endif  // OS/compiler
 }
 

-// wxSnprintf() is like snprintf() if it's available and sprintf() (always
-// available, but dangerous!) if not
-extern int WXDLLEXPORT wxSnprintf(wxChar *buf, size_t len,
-                                  const wxChar *format, ...);
-
-// and wxVsnprintf() is like vsnprintf() or vsprintf()
-extern int WXDLLEXPORT wxVsnprintf(wxChar *buf, size_t len,
-                                   const wxChar *format, va_list argptr);
-

 // return an empty wxString
 class WXDLLEXPORT wxString; // not yet defined
 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }
 // return an empty wxString
 class WXDLLEXPORT wxString; // not yet defined
 inline const wxString& wxGetEmptyString() { return *(wxString *)&wxEmptyString; }


@@ -241,15 +226,8 @@ struct WXDLLEXPORT wxStringData
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 
 //  - regular expressions support
 // ---------------------------------------------------------------------------
 

-#ifdef  WXSTRING_IS_WXOBJECT
-class WXDLLEXPORT wxString : public wxObject
-{
-    DECLARE_DYNAMIC_CLASS(wxString)
-#else   //WXSTRING_IS_WXOBJECT

 class WXDLLEXPORT wxString
 {
 class WXDLLEXPORT wxString
 {

-#endif  //WXSTRING_IS_WXOBJECT
-

 friend class WXDLLEXPORT wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order
 friend class WXDLLEXPORT wxArrayString;
 
   // NB: special care was taken in arranging the member functions in such order


@@ -272,20 +250,20 @@ private:
   void Reinit() { GetStringData()->Unlock(); Init(); }
 
   // memory allocation
   void Reinit() { GetStringData()->Unlock(); Init(); }
 
   // memory allocation

-    // allocates memory for string of lenght nLen
-  void AllocBuffer(size_t nLen);
+    // allocates memory for string of length nLen
+  bool AllocBuffer(size_t nLen);

     // copies data to another string
     // copies data to another string

-  void AllocCopy(wxString&, int, int) const;
+  bool AllocCopy(wxString&, int, int) const;

     // effectively copies data to string
     // effectively copies data to string

-  void AssignCopy(size_t, const wxChar *);
+  bool AssignCopy(size_t, const wxChar *);

 
   // append a (sub)string
 
   // append a (sub)string

-  void ConcatSelf(int nLen, const wxChar *src);
+  bool ConcatSelf(int nLen, const wxChar *src);

 
   // functions called before writing to the string: they copy it if there
   // are other references to our data (should be the only owner when writing)
 
   // functions called before writing to the string: they copy it if there
   // are other references to our data (should be the only owner when writing)

-  void CopyBeforeWrite();
-  void AllocBeforeWrite(size_t);
+  bool CopyBeforeWrite();
+  bool AllocBeforeWrite(size_t);

 
   // if we hadn't made these operators private, it would be possible to
   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly
 
   // if we hadn't made these operators private, it would be possible to
   // compile "wxString s; s = 17;" without any warnings as 17 is implicitly


@@ -305,11 +283,12 @@ private:
 public:
   // constructors and destructor
     // ctor for an empty string
 public:
   // constructors and destructor
     // ctor for an empty string

-  wxString() { Init(); }
+  wxString() : m_pchData(NULL) { Init(); }

     // copy ctor
     // copy ctor

-  wxString(const wxString& stringSrc)
+  wxString(const wxString& stringSrc) : m_pchData(NULL)

   {
   {

-    wxASSERT( stringSrc.GetStringData()->IsValid() );
+    wxASSERT_MSG( stringSrc.GetStringData()->IsValid(),
+                  _T("did you forget to call UngetWriteBuf()?") );

 
     if ( stringSrc.IsEmpty() ) {
       // nothing to do for an empty string
 
     if ( stringSrc.IsEmpty() ) {
       // nothing to do for an empty string


@@ -325,31 +304,35 @@ public:
     // ctor takes first nLength characters from C string
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)
     // ctor takes first nLength characters from C string
     // (default value of wxSTRING_MAXLEN means take all the string)
   wxString(const wxChar *psz, size_t nLength = wxSTRING_MAXLEN)

-    { InitWith(psz, 0, nLength); }
+      : m_pchData(NULL)
+      { InitWith(psz, 0, nLength); }

   wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)
   wxString(const wxChar *psz, wxMBConv& WXUNUSED(conv), size_t nLength = wxSTRING_MAXLEN)

-    { InitWith(psz, 0, nLength); }
+      : m_pchData(NULL)
+      { InitWith(psz, 0, nLength); }

 
 #if wxUSE_UNICODE
     // from multibyte string
     // (NB: nLength is right now number of Unicode characters, not
     //  characters in psz! So try not to use it yet!)
 
 #if wxUSE_UNICODE
     // from multibyte string
     // (NB: nLength is right now number of Unicode characters, not
     //  characters in psz! So try not to use it yet!)

-  wxString(const char *psz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);
+  wxString(const char *psz, wxMBConv& conv, size_t nLength = wxSTRING_MAXLEN);

     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz)
     { InitWith(psz, 0, wxSTRING_MAXLEN); }
 #else // ANSI
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)
     // from wxWCharBuffer (i.e. return from wxGetString)
   wxString(const wxWCharBuffer& psz)
     { InitWith(psz, 0, wxSTRING_MAXLEN); }
 #else // ANSI
     // from C string (for compilers using unsigned char)
   wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)

-    { InitWith((const char*)psz, 0, nLength); }
+      : m_pchData(NULL)
+      { InitWith((const char*)psz, 0, nLength); }

 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string
 
 #if wxUSE_WCHAR_T
     // from wide (Unicode) string

-  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc);
+  wxString(const wchar_t *pwz, wxMBConv& conv = wxConvLibc, size_t nLength = wxSTRING_MAXLEN);

 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
   wxString(const wxCharBuffer& psz)
 #endif // !wxUSE_WCHAR_T
 
     // from wxCharBuffer
   wxString(const wxCharBuffer& psz)

-    { InitWith(psz, 0, wxSTRING_MAXLEN); }
+      : m_pchData(NULL)
+      { InitWith(psz, 0, wxSTRING_MAXLEN); }

 #endif // Unicode/ANSI
 
     // dtor is not virtual, this class must not be inherited from!
 #endif // Unicode/ANSI
 
     // dtor is not virtual, this class must not be inherited from!


@@ -377,8 +360,9 @@ public:
     if ( !GetStringData()->IsEmpty() )
       Reinit();
 
     if ( !GetStringData()->IsEmpty() )
       Reinit();
 

-    wxASSERT( GetStringData()->nDataLength == 0 );  // should be empty
-    wxASSERT( GetStringData()->nAllocLength == 0 ); // and not own any memory
+    wxASSERT_MSG( !GetStringData()->nDataLength &&
+                  !GetStringData()->nAllocLength,
+                  _T("string should be empty after Clear()") );

   }
 
   // contents test
   }
 
   // contents test


@@ -392,20 +376,29 @@ public:
   // data access (all indexes are 0 based)
     // read access
     wxChar  GetChar(size_t n) const
   // data access (all indexes are 0 based)
     // read access
     wxChar  GetChar(size_t n) const

-      { ASSERT_VALID_INDEX( n );  return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n );  return m_pchData[n]; }

     // read/write access
     wxChar& GetWritableChar(size_t n)
     // read/write access
     wxChar& GetWritableChar(size_t n)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

     // write access
     void  SetChar(size_t n, wxChar ch)
     // write access
     void  SetChar(size_t n, wxChar ch)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); m_pchData[n] = ch; }

 
     // get last character
     wxChar  Last() const
 
     // get last character
     wxChar  Last() const

-      { wxASSERT( !IsEmpty() ); return m_pchData[Len() - 1]; }
+      {
+          wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
+
+          return m_pchData[Len() - 1];
+      }
+

     // get writable last character
     wxChar& Last()
     // get writable last character
     wxChar& Last()

-      { wxASSERT( !IsEmpty() ); CopyBeforeWrite(); return m_pchData[Len()-1]; }
+      {
+          wxASSERT_MSG( !IsEmpty(), _T("wxString: index out of bounds") );
+          CopyBeforeWrite();
+          return m_pchData[Len()-1];
+      }

 
     /*
         So why do we have all these overloaded operator[]s? A bit of history:
 
     /*
         So why do we have all these overloaded operator[]s? A bit of history:


@@ -431,36 +424,53 @@ public:
 
     // operator version of GetChar
     wxChar  operator[](size_t n) const
 
     // operator version of GetChar
     wxChar  operator[](size_t n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetChar
     wxChar  operator[](int n) const
 
     // operator version of GetChar
     wxChar  operator[](int n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)
 
     // operator version of GetWriteableChar
     wxChar& operator[](size_t n)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

 
 #ifndef wxSIZE_T_IS_UINT
     // operator version of GetChar
     wxChar operator[](unsigned int n) const
 
 #ifndef wxSIZE_T_IS_UINT
     // operator version of GetChar
     wxChar operator[](unsigned int n) const

-      { ASSERT_VALID_INDEX( n ); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); return m_pchData[n]; }

 
     // operator version of GetWriteableChar
     wxChar& operator[](unsigned int n)
 
     // operator version of GetWriteableChar
     wxChar& operator[](unsigned int n)

-      { ASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }
+      { wxASSERT_VALID_INDEX( n ); CopyBeforeWrite(); return m_pchData[n]; }

 #endif // size_t != unsigned int
 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }
 #endif // size_t != unsigned int
 
     // implicit conversion to C string
     operator const wxChar*() const { return m_pchData; }

+

     // explicit conversion to C string (use this with printf()!)
     const wxChar* c_str()   const { return m_pchData; }
     // explicit conversion to C string (use this with printf()!)
     const wxChar* c_str()   const { return m_pchData; }

-    // identical to c_str()
+    // identical to c_str(), for wxWin 1.6x compatibility

     const wxChar* wx_str()  const { return m_pchData; }
     const wxChar* wx_str()  const { return m_pchData; }

-    // identical to c_str()
+    // identical to c_str(), for MFC compatibility

     const wxChar* GetData() const { return m_pchData; }
 
     const wxChar* GetData() const { return m_pchData; }
 

-    // conversions with (possible) format convertions: have to return a
+    // conversion to/from plain (i.e. 7 bit) ASCII: this is useful for
+    // converting numbers or strings which are certain not to contain special
+    // chars (typically system functions, X atoms, environment variables etc.)
+    //
+    // the behaviour of these functions with the strings containing anything
+    // else than 7 bit ASCII characters is undefined, use at your own risk.
+#if wxUSE_UNICODE
+    static wxString FromAscii(const char *ascii);  // string
+    static wxString FromAscii(const char ascii);   // char
+    const wxCharBuffer ToAscii() const;
+#else // ANSI
+    static wxString FromAscii(const char *ascii) { return wxString( ascii ); }
+    static wxString FromAscii(const char ascii) { return wxString( ascii ); }
+    const char *ToAscii() const { return c_str(); }
+#endif // Unicode/!Unicode
+
+    // conversions with (possible) format conversions: have to return a

     // buffer with temporary data
     //
     // the functions defined (in either Unicode or ANSI) mode are mb_str() to
     // buffer with temporary data
     //
     // the functions defined (in either Unicode or ANSI) mode are mb_str() to


@@ -510,7 +520,8 @@ public:
   wxString& operator=(const wxChar *psz);
 #if wxUSE_UNICODE
     // from wxWCharBuffer
   wxString& operator=(const wxChar *psz);
 #if wxUSE_UNICODE
     // from wxWCharBuffer

-  wxString& operator=(const wxWCharBuffer& psz) { return operator=((const wchar_t *)psz); }
+  wxString& operator=(const wxWCharBuffer& psz)
+  { (void) operator=((const wchar_t *)psz); return *this; }

 #else // ANSI
     // from another kind of C string
   wxString& operator=(const unsigned char* psz);
 #else // ANSI
     // from another kind of C string
   wxString& operator=(const unsigned char* psz);


@@ -519,7 +530,8 @@ public:
   wxString& operator=(const wchar_t *pwz);
 #endif
     // from wxCharBuffer
   wxString& operator=(const wchar_t *pwz);
 #endif
     // from wxCharBuffer

-  wxString& operator=(const wxCharBuffer& psz) { return operator=((const char *)psz); }
+  wxString& operator=(const wxCharBuffer& psz)
+  { (void) operator=((const char *)psz); return *this; }

 #endif // Unicode/ANSI
 
   // string concatenation
 #endif // Unicode/ANSI
 
   // string concatenation


@@ -532,7 +544,8 @@ public:
       // string += string
   wxString& operator<<(const wxString& s)
   {
       // string += string
   wxString& operator<<(const wxString& s)
   {

-    wxASSERT( s.GetStringData()->IsValid() );
+    wxASSERT_MSG( s.GetStringData()->IsValid(),
+                  _T("did you forget to call UngetWriteBuf()?") );

 
     ConcatSelf(s.Len(), s);
     return *this;
 
     ConcatSelf(s.Len(), s);
     return *this;


@@ -552,14 +565,27 @@ public:
 
       // string += buffer (i.e. from wxGetString)
 #if wxUSE_UNICODE
 
       // string += buffer (i.e. from wxGetString)
 #if wxUSE_UNICODE

-  wxString& operator<<(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); return *this; }
-  void operator+=(const wxWCharBuffer& s) { (void)operator<<((const wchar_t *)s); }
-#else
-  wxString& operator<<(const wxCharBuffer& s) { (void)operator<<((const char *)s); return *this; }
-  void operator+=(const wxCharBuffer& s) { (void)operator<<((const char *)s); }
-#endif
+  wxString& operator<<(const wxWCharBuffer& s)
+    { (void)operator<<((const wchar_t *)s); return *this; }
+  void operator+=(const wxWCharBuffer& s)
+    { (void)operator<<((const wchar_t *)s); }
+#else // !wxUSE_UNICODE
+  wxString& operator<<(const wxCharBuffer& s)
+    { (void)operator<<((const char *)s); return *this; }
+  void operator+=(const wxCharBuffer& s)
+    { (void)operator<<((const char *)s); }
+#endif // wxUSE_UNICODE/!wxUSE_UNICODE

 
     // string += C string
 
     // string += C string

+  wxString& Append(const wxString& s)
+    {
+        // test for IsEmpty() to share the string if possible
+        if ( IsEmpty() )
+            *this = s;
+        else
+            ConcatSelf(s.Length(), s.c_str());
+        return *this;
+    }

   wxString& Append(const wxChar* psz)
     { ConcatSelf(wxStrlen(psz), psz); return *this; }
     // append count copies of given character
   wxString& Append(const wxChar* psz)
     { ConcatSelf(wxStrlen(psz), psz); return *this; }
     // append count copies of given character


@@ -686,33 +712,37 @@ public:
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 
     // check if the string contents matches a mask containing '*' and '?'
   bool Matches(const wxChar *szMask) const;
 

-    // conversion to numbers: all functions return TRUE only if the whole string
-    // is a number and put the value of this number into the pointer provided
+    // conversion to numbers: all functions return TRUE only if the whole
+    // string is a number and put the value of this number into the pointer
+    // provided, the base is the numeric base in which the conversion should be
+    // done and must be comprised between 2 and 36 or be 0 in which case the
+    // standard C rules apply (leading '0' => octal, "0x" => hex)

         // convert to a signed integer
         // convert to a signed integer

-    bool ToLong(long *val) const;
+    bool ToLong(long *val, int base = 10) const;

         // convert to an unsigned integer
         // convert to an unsigned integer

-    bool ToULong(unsigned long *val) const;
+    bool ToULong(unsigned long *val, int base = 10) const;

         // convert to a double
     bool ToDouble(double *val) const;
 
   // formated input/output
     // as sprintf(), returns the number of characters written or < 0 on error
         // convert to a double
     bool ToDouble(double *val) const;
 
   // formated input/output
     // as sprintf(), returns the number of characters written or < 0 on error

-  int Printf(const wxChar *pszFormat, ...);
+    // (take 'this' into account in attribute parameter count)
+  int Printf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;

     // as vprintf(), returns the number of characters written or < 0 on error
   int PrintfV(const wxChar* pszFormat, va_list argptr);
 
     // returns the string containing the result of Printf() to it
     // as vprintf(), returns the number of characters written or < 0 on error
   int PrintfV(const wxChar* pszFormat, va_list argptr);
 
     // returns the string containing the result of Printf() to it

-  static wxString Format(const wxChar *pszFormat, ...);
+  static wxString Format(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_1;

     // the same as above, but takes a va_list
   static wxString FormatV(const wxChar *pszFormat, va_list argptr);
 
   // raw access to string memory
     // ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared
     // the same as above, but takes a va_list
   static wxString FormatV(const wxChar *pszFormat, va_list argptr);
 
   // raw access to string memory
     // ensure that string has space for at least nLen characters
     // only works if the data of this string is not shared

-  void Alloc(size_t nLen);
+  bool Alloc(size_t nLen);

     // minimize the string's memory
     // only works if the data of this string is not shared
     // minimize the string's memory
     // only works if the data of this string is not shared

-  void Shrink();
+  bool Shrink();

     // get writable buffer of at least nLen bytes. Unget() *must* be called
     // a.s.a.p. to put string back in a reasonable state!
   wxChar *GetWriteBuf(size_t nLen);
     // get writable buffer of at least nLen bytes. Unget() *must* be called
     // a.s.a.p. to put string back in a reasonable state!
   wxChar *GetWriteBuf(size_t nLen);


@@ -730,8 +760,9 @@ public:
     // values for first parameter of Strip function
   enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
 
     // values for first parameter of Strip function
   enum stripType {leading = 0x1, trailing = 0x2, both = 0x3};
 

-    // use Printf()
-  int sprintf(const wxChar *pszFormat, ...);
+  // use Printf()
+  // (take 'this' into account in attribute parameter count)
+  int sprintf(const wxChar *pszFormat, ...) ATTRIBUTE_PRINTF_2;

 
     // use Cmp()
   inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
 
     // use Cmp()
   inline int CompareTo(const wxChar* psz, caseCompare cmp = exact) const


@@ -780,8 +811,11 @@ public:
   // constructors
     // take nLen chars starting at nPos
   wxString(const wxString& str, size_t nPos, size_t nLen)
   // constructors
     // take nLen chars starting at nPos
   wxString(const wxString& str, size_t nPos, size_t nLen)

+      : m_pchData(NULL)

   {
   {

-    wxASSERT( str.GetStringData()->IsValid() );
+    wxASSERT_MSG( str.GetStringData()->IsValid(),
+                  _T("did you forget to call UngetWriteBuf()?") );
+

     InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
   }
     // take all characters from pStart to pEnd
     InitWith(str.c_str(), nPos, nLen == npos ? 0 : nLen);
   }
     // take all characters from pStart to pEnd


@@ -801,7 +835,7 @@ public:
     // returns true if the string is empty
   bool empty() const { return IsEmpty(); }
     // inform string about planned change in size
     // returns true if the string is empty
   bool empty() const { return IsEmpty(); }
     // inform string about planned change in size

-  void reserve(size_t size) { Alloc(size); }
+  void reserve(size_t sz) { Alloc(sz); }

 
   // lib.string.access
     // return the character at position n
 
   // lib.string.access
     // return the character at position n


@@ -987,9 +1021,21 @@ public:
                                  const wxString& second);
 
   // constructors and destructor
                                  const wxString& second);
 
   // constructors and destructor

-    // default ctor: if autoSort is TRUE, the array is always sorted (in
-    // alphabetical order)
-  wxArrayString(bool autoSort = FALSE);
+    // default ctor
+  wxArrayString()
+      : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
+      { Init(FALSE); }
+    // if autoSort is TRUE, the array is always sorted (in alphabetical order)
+    //
+    // NB: the reason for using int and not bool is that like this we can avoid
+    //     using this ctor for implicit conversions from "const char *" (which
+    //     we'd like to be implicitly converted to wxString instead!)
+    //
+    //     of course, using explicit would be even better - if all compilers
+    //     supported it...
+  wxArrayString(int autoSort)
+      : m_nSize(0), m_nCount(0), m_pItems(NULL), m_autoSort(FALSE)
+      { Init(autoSort != 0); }

     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator
     // copy ctor
   wxArrayString(const wxArrayString& array);
     // assignment operator


@@ -1018,11 +1064,28 @@ public:
   // items access (range checking is done in debug version)
     // get item at position uiIndex
   wxString& Item(size_t nIndex) const
   // items access (range checking is done in debug version)
     // get item at position uiIndex
   wxString& Item(size_t nIndex) const

-    { wxASSERT( nIndex < m_nCount ); return *(wxString *)&(m_pItems[nIndex]); }
+    {
+        wxASSERT_MSG( nIndex < m_nCount,
+                      _T("wxArrayString: index out of bounds") );
+
+        return *(wxString *)&(m_pItems[nIndex]);
+    }
+

     // same as Item()
   wxString& operator[](size_t nIndex) const { return Item(nIndex); }
     // get last item
     // same as Item()
   wxString& operator[](size_t nIndex) const { return Item(nIndex); }
     // get last item

-  wxString& Last() const { wxASSERT( !IsEmpty() ); return Item(Count() - 1); }
+  wxString& Last() const
+  {
+      wxASSERT_MSG( !IsEmpty(),
+                    _T("wxArrayString: index out of bounds") );
+      return Item(Count() - 1);
+  }
+
+    // return a wxString[], useful for the controls which
+    // take one in their ctor.  You must delete[] it yourself
+    // once you are done with it.  Will return NULL if the
+    // ArrayString was empty.
+  wxString* GetStringArray() const;

 
   // item management
     // Search the element in the array, starting from the beginning if
 
   // item management
     // Search the element in the array, starting from the beginning if


@@ -1032,14 +1095,16 @@ public:
   int  Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
     // add new element at the end (if the array is not sorted), return its
     // index
   int  Index (const wxChar *sz, bool bCase = TRUE, bool bFromEnd = FALSE) const;
     // add new element at the end (if the array is not sorted), return its
     // index

-  size_t Add(const wxString& str);
+  size_t Add(const wxString& str, size_t nInsert = 1);

     // add new element at given position
     // add new element at given position

-  void Insert(const wxString& str, size_t uiIndex);
+  void Insert(const wxString& str, size_t uiIndex, size_t nInsert = 1);
+    // expand the array to have count elements
+  void SetCount(size_t count);

     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index
     // remove first item matching this value
   void Remove(const wxChar *sz);
     // remove item by index

-  void Remove(size_t nIndex);
-  void RemoveAt(size_t nIndex) { Remove(nIndex); }
+  void Remove(size_t nIndex, size_t nRemove = 1);
+  void RemoveAt(size_t nIndex, size_t nRemove = 1) { Remove(nIndex, nRemove); }

 
   // sorting
     // sort array elements in alphabetical order (or reversed alphabetical
 
   // sorting
     // sort array elements in alphabetical order (or reversed alphabetical


@@ -1055,10 +1120,11 @@ public:
   bool operator!=(const wxArrayString& a) const { return !(*this == a); }
 
 protected:
   bool operator!=(const wxArrayString& a) const { return !(*this == a); }
 
 protected:

+  void Init(bool autoSort);             // common part of all ctors

   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:
   void Copy(const wxArrayString& src);  // copies the contents of another array
 
 private:

-  void Grow();                          // makes array bigger if needed
+  void Grow(size_t nIncrement = 0);     // makes array bigger if needed

   void Free();                          // free all the strings stored
 
   void DoSort();                        // common part of all Sort() variants
   void Free();                          // free all the strings stored
 
   void DoSort();                        // common part of all Sort() variants


@@ -1080,6 +1146,28 @@ public:
     { Copy(array); }
 };
 
     { Copy(array); }
 };
 

+// ----------------------------------------------------------------------------
+// wxStringBuffer: a tiny class allowing to get a writable pointer into string
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxStringBuffer
+{
+public:
+    wxStringBuffer(wxString& str, size_t lenWanted = 1024)
+        : m_str(str), m_buf(NULL)
+        { m_buf = m_str.GetWriteBuf(lenWanted); }
+
+    ~wxStringBuffer() { m_str.UngetWriteBuf(); }
+
+    operator wxChar*() const { return m_buf; }
+
+private:
+    wxString& m_str;
+    wxChar   *m_buf;
+
+    DECLARE_NO_COPY_CLASS(wxStringBuffer)
+};
+

 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // wxString comparison functions: operator versions are always case sensitive
 // ---------------------------------------------------------------------------


@@ -1169,11 +1257,11 @@ inline wxString operator+(const wxCharBuffer& buf, const wxString& string)
 // ---------------------------------------------------------------------------
 
 // don't pollute the library user's name space
 // ---------------------------------------------------------------------------
 
 // don't pollute the library user's name space

-#undef ASSERT_VALID_INDEX
+#undef wxASSERT_VALID_INDEX

 
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
 
 
 #if defined(wxSTD_STRING_COMPATIBILITY) && wxUSE_STD_IOSTREAM
 

-#include "wx/ioswrap.h"
+#include "wx/iosfwrap.h"

 
 WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
 WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);
 
 WXDLLEXPORT wxSTD istream& operator>>(wxSTD istream&, wxString&);
 WXDLLEXPORT wxSTD ostream& operator<<(wxSTD ostream&, const wxString&);