include/wx/strconv.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        strconv.h
   3 // Purpose:     conversion routines for char sets any Unicode
   4 // Author:      Robert Roebling, Ove Kaaven
   5 // Modified by:
   6 // Created:     29/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Ove Kaaven, Robert Roebling, Vadim Zeitlin
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifndef _WX_WXSTRCONVH__
  13 #define _WX_WXSTRCONVH__
  14
  15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  16   #pragma interface "strconv.h"
  17 #endif
  18
  19 #include "wx/defs.h"
  20 #include "wx/wxchar.h"
  21 #include "wx/buffer.h"
  22
  23 #ifdef __DIGITALMARS__
  24 #include "typeinfo.h"
  25 #endif
  26
  27 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
  28 #  undef __BSEXCPT__
  29 #endif
  30
  31 #include <stdlib.h>
  32
  33 #if wxUSE_WCHAR_T
  34
  35 // ----------------------------------------------------------------------------
  36 // wxMBConv (abstract base class for conversions)
  37 // ----------------------------------------------------------------------------
  38
  39 class WXDLLIMPEXP_BASE wxMBConv
  40 {
  41 public:
  42     // the actual conversion takes place here
  43     //
  44     // note that n is the size of the output buffer, not the length of input
  45     // (which is always supposed to be NUL-terminated)
  46     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const = 0;
  47     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const = 0;
  48
  49     // MB <-> WC
  50     const wxWCharBuffer cMB2WC(const char *psz) const;
  51     const wxCharBuffer cWC2MB(const wchar_t *psz) const;
  52
  53     // convenience functions for converting MB or WC to/from wxWin default
  54 #if wxUSE_UNICODE
  55     const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
  56     const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
  57     const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; }
  58     const wchar_t* cWX2WC(const wchar_t *psz) const { return psz; }
  59 #else // ANSI
  60     const char* cMB2WX(const char *psz) const { return psz; }
  61     const char* cWX2MB(const char *psz) const { return psz; }
  62     const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
  63     const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }
  64 #endif // Unicode/ANSI
  65
  66     // virtual dtor for any base class
  67     virtual ~wxMBConv();
  68 };
  69
  70 // ----------------------------------------------------------------------------
  71 // wxMBConvLibc uses standard mbstowcs() and wcstombs() functions for
  72 //              conversion (hence it depends on the current locale)
  73 // ----------------------------------------------------------------------------
  74
  75 class WXDLLIMPEXP_BASE wxMBConvLibc : public wxMBConv
  76 {
  77 public:
  78     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
  79     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
  80 };
  81
  82 // not very accurately named because it is not necessarily of type wxMBConvLibc
  83 // (but the name can't eb changed because of backwards compatibility) default
  84 // conversion
  85 WXDLLIMPEXP_DATA_BASE(extern wxMBConv&) wxConvLibc;
  86
  87 // ----------------------------------------------------------------------------
  88 // wxMBConvUTF7 (for conversion using UTF7 encoding)
  89 // ----------------------------------------------------------------------------
  90
  91 class WXDLLIMPEXP_BASE wxMBConvUTF7 : public wxMBConv
  92 {
  93 public:
  94     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
  95     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
  96 };
  97
  98 WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF7&) wxConvUTF7;
  99
 100 // ----------------------------------------------------------------------------
 101 // wxMBConvUTF8 (for conversion using UTF8 encoding)
 102 // ----------------------------------------------------------------------------
 103
 104 class WXDLLIMPEXP_BASE wxMBConvUTF8 : public wxMBConv
 105 {
 106 public:
 107     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 108     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 109 };
 110
 111 WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF8&) wxConvUTF8;
 112
 113 // ----------------------------------------------------------------------------
 114 // wxMBConvUTF16LE (for conversion using UTF16 Little Endian encoding)
 115 // ----------------------------------------------------------------------------
 116
 117 class WXDLLIMPEXP_BASE wxMBConvUTF16LE : public wxMBConv
 118 {
 119 public:
 120     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 121     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 122 };
 123
 124 // ----------------------------------------------------------------------------
 125 // wxMBConvUTF16BE (for conversion using UTF16 Big Endian encoding)
 126 // ----------------------------------------------------------------------------
 127
 128 class WXDLLIMPEXP_BASE wxMBConvUTF16BE : public wxMBConv
 129 {
 130 public:
 131     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 132     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 133 };
 134
 135 // ----------------------------------------------------------------------------
 136 // wxMBConvUCS4LE (for conversion using UTF32 Little Endian encoding)
 137 // ----------------------------------------------------------------------------
 138
 139 class WXDLLIMPEXP_BASE wxMBConvUTF32LE : public wxMBConv
 140 {
 141 public:
 142     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 143     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 144 };
 145
 146 // ----------------------------------------------------------------------------
 147 // wxMBConvUCS4BE (for conversion using UTF32 Big Endian encoding)
 148 // ----------------------------------------------------------------------------
 149
 150 class WXDLLIMPEXP_BASE wxMBConvUTF32BE : public wxMBConv
 151 {
 152 public:
 153     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 154     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 155 };
 156
 157 // ----------------------------------------------------------------------------
 158 // wxCSConv (for conversion based on loadable char sets)
 159 // ----------------------------------------------------------------------------
 160
 161 #include "wx/fontenc.h"
 162
 163 class WXDLLIMPEXP_BASE wxCSConv : public wxMBConv
 164 {
 165 public:
 166     // we can be created either from charset name or from an encoding constant
 167     // but we can't have both at once
 168     wxCSConv(const wxChar *charset);
 169     wxCSConv(wxFontEncoding encoding);
 170
 171     wxCSConv(const wxCSConv& conv);
 172     virtual ~wxCSConv();
 173
 174     wxCSConv& operator=(const wxCSConv& conv);
 175
 176     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 177     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 178
 179     void Clear() ;
 180
 181 private:
 182     // common part of all ctors
 183     void Init();
 184
 185     // creates m_convReal if necessary
 186     void CreateConvIfNeeded() const;
 187
 188     // do create m_convReal (unconditionally)
 189     wxMBConv *DoCreate() const;
 190
 191     // set the name (may be only called when m_name == NULL), makes copy of
 192     // charset string
 193     void SetName(const wxChar *charset);
 194
 195
 196     // note that we can't use wxString here because of compilation
 197     // dependencies: we're included from wx/string.h
 198     wxChar *m_name;
 199     wxFontEncoding m_encoding;
 200
 201     // use CreateConvIfNeeded() before accessing m_convReal!
 202     wxMBConv *m_convReal;
 203     bool m_deferred;
 204 };
 205
 206 #define wxConvFile wxConvLocal
 207 WXDLLIMPEXP_DATA_BASE(extern wxCSConv&) wxConvLocal;
 208 WXDLLIMPEXP_DATA_BASE(extern wxCSConv&) wxConvISO8859_1;
 209 WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
 210
 211 // ----------------------------------------------------------------------------
 212 // endianness-dependent conversions
 213 // ----------------------------------------------------------------------------
 214
 215 #ifdef WORDS_BIGENDIAN
 216     typedef wxMBConvUTF16BE wxMBConvUTF16;
 217     typedef wxMBConvUTF32BE wxMBConvUTF32;
 218 #else
 219     typedef wxMBConvUTF16LE wxMBConvUTF16;
 220     typedef wxMBConvUTF32LE wxMBConvUTF32;
 221 #endif
 222
 223 // ----------------------------------------------------------------------------
 224 // filename conversion macros
 225 // ----------------------------------------------------------------------------
 226
 227 // filenames are multibyte on Unix and probably widechar on Windows?
 228 #if defined(__UNIX__) || defined(__BORLANDC__) || defined(__WXMAC__ )
 229     #define wxMBFILES 1
 230 #else
 231     #define wxMBFILES 0
 232 #endif
 233
 234 #if wxMBFILES && wxUSE_UNICODE
 235     #define wxFNCONV(name) wxConvFile.cWX2MB(name)
 236     #define wxFNSTRINGCAST wxMBSTRINGCAST
 237 #else
 238     #define wxFNCONV(name) name
 239     #define wxFNSTRINGCAST WXSTRINGCAST
 240 #endif
 241
 242 #else
 243   // !wxUSE_WCHAR_T
 244
 245 // ----------------------------------------------------------------------------
 246 // stand-ins in absence of wchar_t
 247 // ----------------------------------------------------------------------------
 248
 249 class WXDLLIMPEXP_BASE wxMBConv
 250 {
 251 public:
 252     const char* cMB2WX(const char *psz) const { return psz; }
 253     const char* cWX2MB(const char *psz) const { return psz; }
 254 };
 255
 256 #define wxConvFile wxConvLocal
 257
 258 WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc,
 259                                        wxConvLocal,
 260                                        wxConvISO8859_1,
 261                                        wxConvUTF8;
 262 WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
 263
 264 #define wxFNCONV(name) name
 265 #define wxFNSTRINGCAST WXSTRINGCAST
 266
 267 #endif
 268   // wxUSE_WCHAR_T
 269
 270 // ----------------------------------------------------------------------------
 271 // macros for the most common conversions
 272 // ----------------------------------------------------------------------------
 273
 274 #if wxUSE_UNICODE
 275     #define wxConvertWX2MB(s)   wxConvCurrent->cWX2MB(s)
 276     #define wxConvertMB2WX(s)   wxConvCurrent->cMB2WX(s)
 277 #else // ANSI
 278     // no conversions to do
 279     #define wxConvertWX2MB(s)   (s)
 280     #define wxConvertMB2WX(s)   (s)
 281 #endif // Unicode/ANSI
 282
 283 #endif
 284   // _WX_WXSTRCONVH__
 285