Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more wxMBConv classes cleanup, define wxConvLibc to use Win32 API under Windows

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@23825 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2003-09-22 20:29:15 +00:00
parent 57c5293e49
commit bde4baaced
2 changed files with 105 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
include/wx/strconv.h
View File

@@ -33,20 +33,24 @@
#if wxUSE_WCHAR_T #if wxUSE_WCHAR_T
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMBConv (base class for conversions, using libc conversion itself) // wxMBConv (abstract base class for conversions)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxMBConv class WXDLLIMPEXP_BASE wxMBConv
{ {
public: public:
// the actual conversion takes place here // the actual conversion takes place here
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const; //
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; // note that n is the size of the output buffer, not the length of input
// (which is always supposed to be NUL-terminated)
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const = 0;
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const = 0;
// No longer inline since BC++ complains. // MB <-> WC
const wxWCharBuffer cMB2WC(const char *psz) const; const wxWCharBuffer cMB2WC(const char *psz) const;
const wxCharBuffer cWC2MB(const wchar_t *psz) const; const wxCharBuffer cWC2MB(const wchar_t *psz) const;
// convenience functions for converting MB or WC to/from wxWin default
#if wxUSE_UNICODE #if wxUSE_UNICODE
const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); } const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); } const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
@@ -63,7 +67,22 @@ public:
virtual ~wxMBConv(); virtual ~wxMBConv();
}; };
WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc; // ----------------------------------------------------------------------------
// wxMBConvLibc uses standard mbstowcs() and wcstombs() functions for
// conversion (hence it depends on the current locale)
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_BASE wxMBConvLibc : public wxMBConv
{
public:
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
};
// not very accurately named because it is not necessarily of type wxMBConvLibc
// (but the name can't eb changed because of backwards compatibility) default
// conversion
WXDLLIMPEXP_DATA_BASE(extern wxMBConv&) wxConvLibc;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMBConvUTF7 (for conversion using UTF7 encoding) // wxMBConvUTF7 (for conversion using UTF7 encoding)
@@ -76,7 +95,7 @@ public:
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
}; };
WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF7) wxConvUTF7; WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF7&) wxConvUTF7;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMBConvUTF8 (for conversion using UTF8 encoding) // wxMBConvUTF8 (for conversion using UTF8 encoding)
@@ -89,7 +108,7 @@ public:
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const; virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
}; };
WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF8) wxConvUTF8; WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF8&) wxConvUTF8;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxMBConvUTF16LE (for conversion using UTF16 Little Endian encoding) // wxMBConvUTF16LE (for conversion using UTF16 Little Endian encoding)
@@ -184,8 +203,8 @@ private:
}; };
#define wxConvFile wxConvLocal #define wxConvFile wxConvLocal
WXDLLIMPEXP_DATA_BASE(extern wxCSConv) wxConvLocal; WXDLLIMPEXP_DATA_BASE(extern wxCSConv&) wxConvLocal;
WXDLLIMPEXP_DATA_BASE(extern wxCSConv) wxConvISO8859_1; WXDLLIMPEXP_DATA_BASE(extern wxCSConv&) wxConvISO8859_1;
WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent; WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -233,8 +252,9 @@ public:
const char* cWX2MB(const char *psz) const { return psz; } const char* cWX2MB(const char *psz) const { return psz; }
}; };
#define wxConvFile wxConvLocal
WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc, WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc,
wxConvFile,
wxConvLocal, wxConvLocal,
wxConvISO8859_1, wxConvISO8859_1,
wxConvUTF8; wxConvUTF8;

195
src/common/strconv.cpp
View File

@@ -34,6 +34,10 @@
#include "wx/log.h" #include "wx/log.h"
#endif // WX_PRECOMP #endif // WX_PRECOMP
#include "wx/strconv.h"
#if wxUSE_WCHAR_T
#ifdef __WXMSW__ #ifdef __WXMSW__
#include "wx/msw/private.h" #include "wx/msw/private.h"
#endif #endif
@@ -46,57 +50,14 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include "wx/module.h"
#include "wx/strconv.h"
#if defined(__WIN32__) && !defined(__WXMICROWIN__) #if defined(__WIN32__) && !defined(__WXMICROWIN__)
#define wxHAVE_WIN32_MB2WC #define wxHAVE_WIN32_MB2WC
#endif // __WIN32__ but !__WXMICROWIN__ #endif // __WIN32__ but !__WXMICROWIN__
// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------
#if wxUSE_WCHAR_T
WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc;
WXDLLIMPEXP_DATA_BASE(wxCSConv) wxConvLocal((const wxChar *)NULL);
WXDLLIMPEXP_DATA_BASE(wxCSConv) wxConvISO8859_1(_T("iso-8859-1"));
#else
// stand-ins in absence of wchar_t
WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
wxConvFile,
wxConvISO8859_1,
wxConvLocal,
wxConvUTF8;
#endif // wxUSE_WCHAR_T
WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibc;
class wxStrConvModule: public wxModule
{
public:
wxStrConvModule() : wxModule() { }
virtual bool OnInit() { return true; }
virtual void OnExit()
{
#if wxUSE_WCHAR_T
wxConvLocal.Clear();
wxConvISO8859_1.Clear();
#endif
}
DECLARE_DYNAMIC_CLASS(wxStrConvModule)
};
IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// headers // headers
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#if wxUSE_WCHAR_T
#ifdef __SALFORDC__ #ifdef __SALFORDC__
#include <clib.h> #include <clib.h>
#endif #endif
@@ -115,12 +76,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
#define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); } #define BSWAP_UCS4(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT32_SWAP_ALWAYS(str[_c]); }
#define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); } #define BSWAP_UTF16(str, len) { unsigned _c; for (_c=0; _c<len; _c++) str[_c]=wxUINT16_SWAP_ALWAYS(str[_c]); }
// under Unix SIZEOF_WCHAR_T is defined by configure, but under other platforms
// it might be not defined - assume the most common value
#ifndef SIZEOF_WCHAR_T
#define SIZEOF_WCHAR_T 2
#endif // !defined(SIZEOF_WCHAR_T)
#if SIZEOF_WCHAR_T == 4 #if SIZEOF_WCHAR_T == 4
#define WC_NAME "UCS4" #define WC_NAME "UCS4"
#define WC_BSWAP BSWAP_UCS4 #define WC_BSWAP BSWAP_UCS4
@@ -139,8 +94,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxStrConvModule, wxModule)
#define WC_NAME_BEST "UTF-16LE" #define WC_NAME_BEST "UTF-16LE"
#endif #endif
#else // sizeof(wchar_t) != 2 nor 4 #else // sizeof(wchar_t) != 2 nor 4
// I don't know what to do about this // does this ever happen?
#error "Weird sizeof(wchar_t): please report your platform details to wx-users mailing list" #error "Unknown sizeof(wchar_t): please report this to wx-dev@lists.wxwindows.org"
#endif #endif
// ============================================================================ // ============================================================================
@@ -198,49 +153,11 @@ static size_t decode_utf16(const wxUint16* input, wxUint32& output)
// wxMBConv // wxMBConv
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#define IGNORE_LIBC 0
wxMBConv::~wxMBConv() wxMBConv::~wxMBConv()
{ {
// nothing to do here // nothing to do here
} }
size_t wxMBConv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
{
#if IGNORE_LIBC
if (buf)
{
for (size_t i = 0; i < strlen( psz )+1; i++)
buf[i] = (wchar_t) psz[i];
return strlen( psz );
}
else
{
return strlen( psz );
}
#else
return wxMB2WC(buf, psz, n);
#endif
}
size_t wxMBConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
{
#if IGNORE_LIBC
if (buf)
{
for (size_t i = 0; i < wxStrlen( psz )+1; i++)
buf[i] = (char) psz[i];
return wxStrlen( psz );
}
else
{
return wxStrlen( psz );
}
#else
return wxWC2MB(buf, psz, n);
#endif
}
const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const const wxWCharBuffer wxMBConv::cMB2WC(const char *psz) const
{ {
if ( psz ) if ( psz )
@@ -282,10 +199,22 @@ const wxCharBuffer wxMBConv::cWC2MB(const wchar_t *pwz) const
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// UTF-7 // wxMBConvLibc
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7) wxConvUTF7; size_t wxMBConvLibc::MB2WC(wchar_t *buf, const char *psz, size_t n) const
{
return wxMB2WC(buf, psz, n);
}
size_t wxMBConvLibc::WC2MB(char *buf, const wchar_t *psz, size_t n) const
{
return wxWC2MB(buf, psz, n);
}
// ----------------------------------------------------------------------------
// UTF-7
// ----------------------------------------------------------------------------
#if 0 #if 0
static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ" static char utf7_setD[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
@@ -316,8 +245,6 @@ size_t wxMBConvUTF7::WC2MB(char * WXUNUSED(buf),
// UTF-8 // UTF-8
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8) wxConvUTF8;
static wxUint32 utf8_max[]= static wxUint32 utf8_max[]=
{ 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff }; { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff, 0xffffffff };
@@ -433,24 +360,16 @@ size_t wxMBConvUTF8::WC2MB(char *buf, const wchar_t *psz, size_t n) const
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
#define wxMBConvUTF16straight wxMBConvUTF16BE #define wxMBConvUTF16straight wxMBConvUTF16BE
#define wxMBConvUTF16swap wxMBConvUTF16LE #define wxMBConvUTF16swap wxMBConvUTF16LE
#else #else
#define wxMBConvUTF16swap wxMBConvUTF16BE #define wxMBConvUTF16swap wxMBConvUTF16BE
#define wxMBConvUTF16straight wxMBConvUTF16LE #define wxMBConvUTF16straight wxMBConvUTF16LE
#endif #endif
WXDLLIMPEXP_DATA_BASE(wxMBConvUTF16LE) wxConvUTF16LE;
WXDLLIMPEXP_DATA_BASE(wxMBConvUTF16BE) wxConvUTF16BE;
#ifdef WC_UTF16 #ifdef WC_UTF16
// copy 16bit MB to 16bit String // copy 16bit MB to 16bit String
size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const size_t wxMBConvUTF16straight::MB2WC(wchar_t *buf, const char *psz, size_t n) const
{ {
@@ -918,8 +837,8 @@ public:
wxMBConv_iconv(const wxChar *name); wxMBConv_iconv(const wxChar *name);
virtual ~wxMBConv_iconv(); virtual ~wxMBConv_iconv();
virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n); virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n); virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
bool IsOk() const bool IsOk() const
{ return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); } { return (m2w != (iconv_t)-1) && (w2m != (iconv_t)-1); }
@@ -1038,7 +957,7 @@ wxMBConv_iconv::~wxMBConv_iconv()
iconv_close(w2m); iconv_close(w2m);
} }
size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n) const
{ {
size_t inbuf = strlen(psz); size_t inbuf = strlen(psz);
size_t outbuf = n * SIZEOF_WCHAR_T; size_t outbuf = n * SIZEOF_WCHAR_T;
@@ -1095,7 +1014,7 @@ size_t wxMBConv_iconv::MB2WC(wchar_t *buf, const char *psz, size_t n)
return res; return res;
} }
size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) size_t wxMBConv_iconv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
{ {
size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T; size_t inbuf = wxWcslen(psz) * SIZEOF_WCHAR_T;
size_t outbuf = n; size_t outbuf = n;
@@ -1174,17 +1093,22 @@ extern WXDLLIMPEXP_BASE long wxEncodingToCodepage(wxFontEncoding encoding);
class wxMBConv_win32 : public wxMBConv class wxMBConv_win32 : public wxMBConv
{ {
public: public:
wxMBConv_win32()
{
m_CodePage = CP_ACP;
}
wxMBConv_win32(const wxChar* name) wxMBConv_win32(const wxChar* name)
{ {
m_CodePage = wxCharsetToCodepage(name); m_CodePage = wxCharsetToCodepage(name);
} }
wxMBConv_win32(wxFontEncoding encoding) wxMBConv_win32(wxFontEncoding encoding)
{ {
m_CodePage = wxEncodingToCodepage(encoding); m_CodePage = wxEncodingToCodepage(encoding);
} }
size_t MB2WC(wchar_t *buf, const char *psz, size_t n) size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const
{ {
const size_t len = ::MultiByteToWideChar const size_t len = ::MultiByteToWideChar
( (
@@ -1201,7 +1125,7 @@ public:
return len ? (buf ? len : len - 1) : (size_t)-1; return len ? (buf ? len : len - 1) : (size_t)-1;
} }
size_t WC2MB(char *buf, const wchar_t *psz, size_t n) size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const
{ {
const size_t len = ::WideCharToMultiByte const size_t len = ::WideCharToMultiByte
( (
@@ -1264,7 +1188,7 @@ public:
Init(); Init();
} }
size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) size_t MB2WC(wchar_t *buf, const char *psz, size_t WXUNUSED(n)) const
{ {
size_t inbuf = strlen(psz); size_t inbuf = strlen(psz);
if (buf) if (buf)
@@ -1272,7 +1196,7 @@ public:
return inbuf; return inbuf;
} }
size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) size_t WC2MB(char *buf, const wchar_t *psz, size_t WXUNUSED(n)) const
{ {
const size_t inbuf = wxWcslen(psz); const size_t inbuf = wxWcslen(psz);
if (buf) if (buf)
@@ -1565,6 +1489,37 @@ size_t wxCSConv::WC2MB(char *buf, const wchar_t *psz, size_t n) const
return len; return len;
} }
#endif // wxUSE_WCHAR_T // ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------
#ifdef __WINDOWS__
static wxMBConv_win32 wxConvLibcObj;
#else
static wxMBConvSystem wxConvLibcObj;
#endif
static wxCSConv wxConvLocalObj(wxFONTENCODING_SYSTEM);
static wxCSConv wxConvISO8859_1Obj(wxFONTENCODING_ISO8859_1);
static wxMBConvUTF7 wxConvUTF7Obj;
static wxMBConvUTF8 wxConvUTF8Obj;
WXDLLIMPEXP_DATA_BASE(wxMBConv&) wxConvLibc = wxConvLibcObj;
WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvLocal = wxConvLocalObj;
WXDLLIMPEXP_DATA_BASE(wxCSConv&) wxConvISO8859_1 = wxConvISO8859_1Obj;
WXDLLIMPEXP_DATA_BASE(wxMBConvUTF7&) wxConvUTF7 = wxConvUTF7Obj;
WXDLLIMPEXP_DATA_BASE(wxMBConvUTF8&) wxConvUTF8 = wxConvUTF8Obj;
WXDLLIMPEXP_DATA_BASE(wxMBConv *) wxConvCurrent = &wxConvLibcObj;
#else // !wxUSE_WCHAR_T
// stand-ins in absence of wchar_t
WXDLLIMPEXP_DATA_BASE(wxMBConv) wxConvLibc,
wxConvISO8859_1,
wxConvLocal,
wxConvUTF8;
#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T