]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/wxchar.cpp
really show the menubar (calling Show(TRUE) doesn't do it any more)
[wxWidgets.git] / src / common / wxchar.cpp
index bca67b1228054d2a72441895923c0da1aca875ef..a7a37548aa1184d5bada10f7dcc2ddeccf4f6a22 100644 (file)
@@ -2,14 +2,14 @@
 // Name:        wxchar.cpp
 // Purpose:     wxChar implementation
 // Author:      Ove Kåven
-// Modified by:
+// Modified by: Ron Lee
 // Created:     09/04/99
 // RCS-ID:      $Id$
 // Copyright:   (c) wxWindows copyright
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
   #pragma implementation "wxchar.h"
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <locale.h>
+
+#ifndef __WXWINCE__
 #include <time.h>
+#include <locale.h>
+#else
+#include "wx/msw/wince/time.h"
+#endif
 
 #ifndef WX_PRECOMP
   #include "wx/defs.h"
   #include <winnt.h>
 #endif
 
+#if defined(__MWERKS__) && __MSL__ >= 0x6000
+using namespace std ;
+#endif
+
+#ifdef __WXMAC__
+    #include "wx/mac/private.h"
+#endif
+
 #if wxUSE_WCHAR_T
 size_t WXDLLEXPORT wxMB2WC(wchar_t *buf, const char *psz, size_t n)
 {
+  // assume that we have mbsrtowcs() too if we have wcsrtombs()
+#if HAVE_WCSRTOMBS
+  mbstate_t mbstate;
+  memset(&mbstate, 0, sizeof(mbstate_t));
+#endif
+
   if (buf) {
     if (!n || !*psz) {
       if (n) *buf = wxT('\0');
       return 0;
     }
+#ifdef HAVE_WCSRTOMBS
+    return mbsrtowcs(buf, &psz, n, &mbstate);
+#else
     return mbstowcs(buf, psz, n);
+#endif
   }
 
-  // assume that we have mbsrtowcs() too if we have wcsrtombs()
 #ifdef HAVE_WCSRTOMBS
-  mbstate_t mbstate;
   return mbsrtowcs((wchar_t *) NULL, &psz, 0, &mbstate);
-#else  // !GNU libc
+#else
   return mbstowcs((wchar_t *) NULL, psz, 0);
-#endif // GNU
+#endif
 }
 
 size_t WXDLLEXPORT wxWC2MB(char *buf, const wchar_t *pwz, size_t n)
 {
+#if HAVE_WCSRTOMBS
+  mbstate_t mbstate;
+  memset(&mbstate, 0, sizeof(mbstate_t));
+#endif
+
   if (buf) {
     if (!n || !*pwz) {
       // glibc2.1 chokes on null input
       if (n) *buf = '\0';
       return 0;
     }
+#if HAVE_WCSRTOMBS
+    return wcsrtombs(buf, &pwz, n, &mbstate);
+#else
     return wcstombs(buf, pwz, n);
+#endif
   }
 
 #if HAVE_WCSRTOMBS
-  mbstate_t mbstate;
   return wcsrtombs((char *) NULL, &pwz, 0, &mbstate);
-#else  // !GNU libc
+#else
   return wcstombs((char *) NULL, pwz, 0);
-#endif // GNU
+#endif
 }
 #endif // wxUSE_WCHAR_T
 
 bool WXDLLEXPORT wxOKlibc()
 {
-#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__)
+#if wxUSE_WCHAR_T && defined(__UNIX__) && defined(__GLIBC__) && !defined(__WINE__)
   // glibc 2.0 uses UTF-8 even when it shouldn't
   wchar_t res = 0;
   if ((MB_CUR_MAX == 2) &&
@@ -511,6 +540,23 @@ int WXDLLEXPORT wxSnprintf_(wxChar *buf, size_t len, const wxChar *format, ...)
 }
 #endif // wxSnprintf_
 
+#if defined(__DMC__)
+    /* Digital Mars adds count to _stprintf (C99) so convert */
+    #if wxUSE_UNICODE
+        int wxSprintf (wchar_t * __RESTRICT s, const wchar_t * __RESTRICT format, ... )
+        {
+            va_list arglist;
+
+            va_start( arglist, format );
+            int iLen = swprintf ( s, -1, format, arglist );
+            va_end( arglist );
+            return iLen ;
+        }
+
+    #endif // wxUSE_UNICODE
+
+#endif //__DMC__
+
 // ----------------------------------------------------------------------------
 // implement the standard IO functions for wide char if libc doesn't have them
 // ----------------------------------------------------------------------------
@@ -570,7 +616,7 @@ int vfwprintf(FILE *stream, const wxChar *format, va_list argptr)
     if ( rc != -1 )
     {
         // we can't do much better without Unicode support in libc...
-        if ( fprintf(stream, "%s", s.mb_str()) == -1 )
+        if ( fprintf(stream, "%s", (const char*)s.mb_str() ) == -1 )
             return -1;
     }
 
@@ -723,7 +769,11 @@ wxFormatConverter::wxFormatConverter(const wxChar *format)
             // precision?
             if ( *format == _T('.') )
             {
-                SkipDigits(&format);
+                CopyFmtChar(*format++);
+                if ( *format == _T('*') )
+                    CopyFmtChar(*format++);
+                else
+                    SkipDigits(&format);
             }
 
             // next we can have a size modifier
@@ -770,23 +820,14 @@ wxFormatConverter::wxFormatConverter(const wxChar *format)
                 case _T('c'):
                 case _T('s'):
                     // %c -> %lc but %hc stays %hc and %lc is still %lc
-                    switch ( size )
-                    {
-                        case Default:
-                            InsertFmtChar(_T('l'));
-                            break;
-
-                        case Short:
-                            CopyFmtChar(_T('h'));
-                            break;
-
-                        case Long:
-                            ;
-                    }
+                    if ( size == Default)
+                        InsertFmtChar(_T('l'));
                     // fall through
 
                 default:
                     // nothing special to do
+                    if ( size != Default )
+                        CopyFmtChar(*(format - 1));
                     CopyFmtChar(*format++);
             }
         }
@@ -798,6 +839,14 @@ wxFormatConverter::wxFormatConverter(const wxChar *format)
     #define wxFormatConverter(x) (x)
 #endif // wxNEED_PRINTF_CONVERSION/!wxNEED_PRINTF_CONVERSION
 
+#ifdef __WXDEBUG__
+// For testing the format converter
+wxString wxConvertFormat(const wxChar *format)
+{
+    return wxString(wxFormatConverter(format));
+}
+#endif
+
 // ----------------------------------------------------------------------------
 // wxPrintf(), wxScanf() and relatives
 // ----------------------------------------------------------------------------
@@ -832,7 +881,6 @@ int wxFscanf( FILE *stream, const wxChar *format, ... )
 {
     va_list argptr;
     va_start(argptr, format);
-
     int ret = vfwscanf(stream, wxFormatConverter(format), argptr);
 
     va_end(argptr);
@@ -871,12 +919,14 @@ int wxSprintf( wxChar *str, const wxChar *format, ... )
     va_list argptr;
     va_start(argptr, format);
 
-    // callers of wxSprintf() deserve what they get
-    int ret = vswprintf( str, UINT_MAX, wxFormatConverter(format), argptr );
+    // note that wxString::Format() uses wxVsnprintf(), not wxSprintf(), so
+    // it's safe to implement this one in terms of it
+    wxString s(wxString::Format(format, argptr));
+    wxStrcpy(str, s);
 
     va_end(argptr);
 
-    return ret;
+    return s.length();
 }
 
 int wxFprintf( FILE *stream, const wxChar *format, ... )
@@ -916,11 +966,13 @@ int wxVsnprintf( wxChar *str, size_t size, const wxChar *format, va_list argptr
 int wxVsprintf( wxChar *str, const wxChar *format, va_list argptr )
 {
     // same as for wxSprintf()
-    return vswprintf(str, UINT_MAX, wxFormatConverter(format), argptr);
+    return vswprintf(str, INT_MAX / 4, wxFormatConverter(format), argptr);
 }
 
 #endif // wxNEED_PRINTF_CONVERSION
 
+#if wxUSE_WCHAR_T
+
 // ----------------------------------------------------------------------------
 // ctype.h stuff (currently unused)
 // ----------------------------------------------------------------------------
@@ -935,7 +987,7 @@ inline WORD wxMSW_ctype(wxChar ch)
 
 WXDLLEXPORT int wxIsalnum(wxChar ch) { return IsCharAlphaNumeric(ch); }
 WXDLLEXPORT int wxIsalpha(wxChar ch) { return IsCharAlpha(ch); }
-WXDLLEXPORT int wxIsctrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
+WXDLLEXPORT int wxIscntrl(wxChar ch) { return wxMSW_ctype(ch) & C1_CNTRL; }
 WXDLLEXPORT int wxIsdigit(wxChar ch) { return wxMSW_ctype(ch) & C1_DIGIT; }
 WXDLLEXPORT int wxIsgraph(wxChar ch) { return wxMSW_ctype(ch) & (C1_DIGIT|C1_PUNCT|C1_ALPHA); }
 WXDLLEXPORT int wxIslower(wxChar ch) { return IsCharLower(ch); }
@@ -948,15 +1000,26 @@ WXDLLEXPORT int wxTolower(wxChar ch) { return (wxChar)CharLower((LPTSTR)(ch)); }
 WXDLLEXPORT int wxToupper(wxChar ch) { return (wxChar)CharUpper((LPTSTR)(ch)); }
 #endif
 
-#ifndef wxStrdup
-WXDLLEXPORT wxChar * wxStrdup(const wxChar *psz)
+#ifndef wxStrdupA
+
+WXDLLEXPORT char *wxStrdupA(const char *s)
 {
-  size_t size = (wxStrlen(psz) + 1) * sizeof(wxChar);
-  wxChar *ret = (wxChar *) malloc(size);
-  memcpy(ret, psz, size);
+    return strcpy((char *)malloc(strlen(s) + 1), s);
+}
+
+#endif // wxStrdupA
+
+#ifndef wxStrdupW
+
+WXDLLEXPORT wchar_t * wxStrdupW(const wchar_t *pwz)
+{
+  size_t size = (wxWcslen(pwz) + 1) * sizeof(wchar_t);
+  wchar_t *ret = (wchar_t *) malloc(size);
+  memcpy(ret, pwz, size);
   return ret;
 }
-#endif
+
+#endif // wxStrdupW
 
 #ifndef wxStricmp
 int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
@@ -973,7 +1036,8 @@ int WXDLLEXPORT wxStricmp(const wxChar *psz1, const wxChar *psz2)
 #ifndef wxStricmp
 int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
 {
-  register wxChar c1, c2;
+  // initialize the variables just to suppress stupid gcc warning
+  register wxChar c1 = 0, c2 = 0;
   while (n && ((c1 = wxTolower(*s1)) == (c2 = wxTolower(*s2)) ) && c1) n--, s1++, s2++;
   if (n) {
     if (c1 < c2) return -1;
@@ -983,39 +1047,6 @@ int WXDLLEXPORT wxStrnicmp(const wxChar *s1, const wxChar *s2, size_t n)
 }
 #endif
 
-#ifndef wxStrtok
-WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
-{
-    if (!psz)
-    {
-        psz = *save_ptr;
-        if ( !psz )
-            return NULL;
-    }
-
-    psz += wxStrspn(psz, delim);
-    if (!*psz)
-    {
-        *save_ptr = (wxChar *)NULL;
-        return (wxChar *)NULL;
-    }
-
-    wxChar *ret = psz;
-    psz = wxStrpbrk(psz, delim);
-    if (!psz)
-    {
-        *save_ptr = (wxChar*)NULL;
-    }
-    else
-    {
-        *psz = wxT('\0');
-        *save_ptr = psz + 1;
-    }
-
-    return ret;
-}
-#endif // wxStrtok
-
 #ifndef wxSetlocale
 WXDLLEXPORT wxWCharBuffer wxSetlocale(int category, const wxChar *locale)
 {
@@ -1229,7 +1260,16 @@ WXDLLEXPORT int wxRename(const wxChar *oldpath, const wxChar *newpath)
 #ifndef wxAtof
 double   WXDLLEXPORT wxAtof(const wxChar *psz)
 {
-  return atof(wxConvLocal.cWX2MB(psz));
+#ifdef __WXWINCE__
+    double d;
+    wxString str(psz);
+    if (str.ToDouble(& d))
+        return d;
+    else
+        return 0.0;
+#else
+    return atof(wxConvLocal.cWX2MB(psz));
+#endif
 }
 #endif
 
@@ -1265,7 +1305,7 @@ wxChar * WXDLLEXPORT wxGetenv(const wxChar *name)
     // printf( "home %s\n", val );
 
     // convert it,
-#ifdef wxUSE_UNICODE
+#if wxUSE_UNICODE
     data = (wxObject *)new wxString(val, wxConvLocal);
 #else
     data = (wxObject *)new wxString(val);
@@ -1283,7 +1323,7 @@ int WXDLLEXPORT wxSystem(const wxChar *psz)
     return system(wxConvLocal.cWX2MB(psz));
 }
 
-#endif
+#endif // wxNEED_WX_STDLIB_H
 
 #ifdef wxNEED_WX_TIME_H
 WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const struct tm *tm)
@@ -1305,4 +1345,98 @@ WXDLLEXPORT size_t   wxStrftime(wxChar *s, size_t max, const wxChar *fmt, const
         return 0;
   }
 }
+#endif // wxNEED_WX_TIME_H
+
+#ifndef wxCtime
+WXDLLEXPORT wxChar *wxCtime(const time_t *timep)
+{
+    static wxChar   buf[128];
+
+    wxStrncpy( buf, wxConvertMB2WX( ctime( timep ) ), sizeof( buf ) );
+    buf[ sizeof( buf ) - 1 ] = _T('\0');
+
+    return buf;
+}
+#endif // wxCtime
+
+#endif // wxUSE_WCHAR_T
+
+// ----------------------------------------------------------------------------
+// functions which we may need even if !wxUSE_WCHAR_T
+// ----------------------------------------------------------------------------
+
+#ifndef wxStrtok
+
+WXDLLEXPORT wxChar * wxStrtok(wxChar *psz, const wxChar *delim, wxChar **save_ptr)
+{
+    if (!psz)
+    {
+        psz = *save_ptr;
+        if ( !psz )
+            return NULL;
+    }
+
+    psz += wxStrspn(psz, delim);
+    if (!*psz)
+    {
+        *save_ptr = (wxChar *)NULL;
+        return (wxChar *)NULL;
+    }
+
+    wxChar *ret = psz;
+    psz = wxStrpbrk(psz, delim);
+    if (!psz)
+    {
+        *save_ptr = (wxChar*)NULL;
+    }
+    else
+    {
+        *psz = wxT('\0');
+        *save_ptr = psz + 1;
+    }
+
+    return ret;
+}
+
+#endif // wxStrtok
+
+// ----------------------------------------------------------------------------
+// missing C RTL functions
+// ----------------------------------------------------------------------------
+
+#if (defined(__MWERKS__) && !defined(__MACH__) && (__MSL__ < 0x00008000)) || \
+     defined(__WXWINCE__)
+char *strdup(const char *s)
+{
+    char *dest = (char*) malloc( strlen( s ) + 1 ) ;
+    if ( dest )
+        strcpy( dest , s ) ;
+    return dest ;
+}
+#endif
+
+#if (defined(__MWERKS__) && !defined(__MACH__)) || (defined(__WXWINCE__) && _WIN32_WCE <= 211)
+
+int isascii( int c )
+{
+    return ( c >= 0 && c < 128 );
+}
 #endif
+
+#if defined(__WXWINCE__) && (_WIN32_WCE <= 211)
+#if (_WIN32_WCE < 300)
+void *calloc( size_t num, size_t size )
+{
+    void** ptr = (void **)malloc(num * size);
+    memset( ptr, 0, num * size);
+    return ptr;
+}
+#endif
+
+int isspace(int c)
+{
+    return (c == ' ');
+}
+
+#endif
+