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 (base class for conversions, using libc conversion itself)
  37 // ----------------------------------------------------------------------------
  38
  39 class WXDLLIMPEXP_BASE wxMBConv
  40 {
  41 public:
  42     // the actual conversion takes place here
  43     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
  44     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
  45
  46     // No longer inline since BC++ complains.
  47     const wxWCharBuffer cMB2WC(const char *psz) const;
  48     const wxCharBuffer cWC2MB(const wchar_t *psz) const;
  49
  50 #if wxUSE_UNICODE
  51     const wxWCharBuffer cMB2WX(const char *psz) const { return cMB2WC(psz); }
  52     const wxCharBuffer cWX2MB(const wchar_t *psz) const { return cWC2MB(psz); }
  53     const wchar_t* cWC2WX(const wchar_t *psz) const { return psz; }
  54     const wchar_t* cWX2WC(const wchar_t *psz) const { return psz; }
  55 #else // ANSI
  56     const char* cMB2WX(const char *psz) const { return psz; }
  57     const char* cWX2MB(const char *psz) const { return psz; }
  58     const wxCharBuffer cWC2WX(const wchar_t *psz) const { return cWC2MB(psz); }
  59     const wxWCharBuffer cWX2WC(const char *psz) const { return cMB2WC(psz); }
  60 #endif // Unicode/ANSI
  61
  62     // virtual dtor for any base class
  63     virtual ~wxMBConv();
  64 };
  65
  66 WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc;
  67
  68 // ----------------------------------------------------------------------------
  69 // wxMBConvUTF7 (for conversion using UTF7 encoding)
  70 // ----------------------------------------------------------------------------
  71
  72 class WXDLLIMPEXP_BASE wxMBConvUTF7 : public wxMBConv
  73 {
  74 public:
  75     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
  76     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
  77 };
  78
  79 WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF7) wxConvUTF7;
  80
  81 // ----------------------------------------------------------------------------
  82 // wxMBConvUTF8 (for conversion using UTF8 encoding)
  83 // ----------------------------------------------------------------------------
  84
  85 class WXDLLIMPEXP_BASE wxMBConvUTF8 : public wxMBConv
  86 {
  87 public:
  88     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
  89     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
  90 };
  91
  92 WXDLLIMPEXP_DATA_BASE(extern wxMBConvUTF8) wxConvUTF8;
  93
  94 // ----------------------------------------------------------------------------
  95 // wxMBConvUTF16LE (for conversion using UTF16 Little Endian encoding)
  96 // ----------------------------------------------------------------------------
  97
  98 class WXDLLIMPEXP_BASE wxMBConvUTF16LE : public wxMBConv
  99 {
 100 public:
 101     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 102     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 103 };
 104
 105 // ----------------------------------------------------------------------------
 106 // wxMBConvUTF16BE (for conversion using UTF16 Big Endian encoding)
 107 // ----------------------------------------------------------------------------
 108
 109 class WXDLLIMPEXP_BASE wxMBConvUTF16BE : public wxMBConv
 110 {
 111 public:
 112     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 113     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 114 };
 115
 116 // ----------------------------------------------------------------------------
 117 // wxMBConvUCS4LE (for conversion using UTF32 Little Endian encoding)
 118 // ----------------------------------------------------------------------------
 119
 120 class WXDLLIMPEXP_BASE wxMBConvUTF32LE : public wxMBConv
 121 {
 122 public:
 123     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 124     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 125 };
 126
 127 // ----------------------------------------------------------------------------
 128 // wxMBConvUCS4BE (for conversion using UTF32 Big Endian encoding)
 129 // ----------------------------------------------------------------------------
 130
 131 class WXDLLIMPEXP_BASE wxMBConvUTF32BE : public wxMBConv
 132 {
 133 public:
 134     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 135     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 136 };
 137
 138 // ----------------------------------------------------------------------------
 139 // wxCSConv (for conversion based on loadable char sets)
 140 // ----------------------------------------------------------------------------
 141
 142 #include "wx/fontenc.h"
 143
 144 class WXDLLIMPEXP_BASE wxCharacterSet;
 145
 146 class WXDLLIMPEXP_BASE wxCSConv : public wxMBConv
 147 {
 148 public:
 149     wxCSConv(const wxChar *charset);
 150     wxCSConv(wxFontEncoding encoding);
 151     wxCSConv(const wxCSConv& conv);
 152     virtual ~wxCSConv();
 153
 154     wxCSConv& operator=(const wxCSConv& conv);
 155
 156     void LoadNow();
 157
 158     virtual size_t MB2WC(wchar_t *buf, const char *psz, size_t n) const;
 159     virtual size_t WC2MB(char *buf, const wchar_t *psz, size_t n) const;
 160
 161     void Clear() ;
 162
 163 private:
 164     // common part of all ctors
 165     void Init();
 166
 167     void SetName(const wxChar *charset);
 168
 169     // note that we can't use wxString here because of compilation
 170     // dependencies: we're included from wx/string.h
 171     wxChar *m_name;
 172     wxCharacterSet *m_cset;
 173     wxFontEncoding m_encoding;
 174     bool m_deferred;
 175 };
 176
 177 #define wxConvFile wxConvLocal
 178 WXDLLIMPEXP_DATA_BASE(extern wxCSConv) wxConvLocal;
 179 WXDLLIMPEXP_DATA_BASE(extern wxCSConv) wxConvISO8859_1;
 180 WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
 181
 182 // ----------------------------------------------------------------------------
 183 // filename conversion macros
 184 // ----------------------------------------------------------------------------
 185
 186 // filenames are multibyte on Unix and probably widechar on Windows?
 187 #if defined(__UNIX__) || defined(__BORLANDC__) || defined(__WXMAC__ )
 188     #define wxMBFILES 1
 189 #else
 190     #define wxMBFILES 0
 191 #endif
 192
 193 #if wxMBFILES && wxUSE_UNICODE
 194     #define wxFNCONV(name) wxConvFile.cWX2MB(name)
 195     #define wxFNSTRINGCAST wxMBSTRINGCAST
 196 #else
 197     #define wxFNCONV(name) name
 198     #define wxFNSTRINGCAST WXSTRINGCAST
 199 #endif
 200
 201 #else
 202   // !wxUSE_WCHAR_T
 203
 204 // ----------------------------------------------------------------------------
 205 // stand-ins in absence of wchar_t
 206 // ----------------------------------------------------------------------------
 207
 208 class WXDLLIMPEXP_BASE wxMBConv
 209 {
 210 public:
 211     const char* cMB2WX(const char *psz) const { return psz; }
 212     const char* cWX2MB(const char *psz) const { return psz; }
 213 };
 214
 215 WXDLLIMPEXP_DATA_BASE(extern wxMBConv) wxConvLibc,
 216                                        wxConvFile,
 217                                        wxConvLocal,
 218                                        wxConvISO8859_1,
 219                                        wxConvUTF8;
 220 WXDLLIMPEXP_DATA_BASE(extern wxMBConv *) wxConvCurrent;
 221
 222 #define wxFNCONV(name) name
 223 #define wxFNSTRINGCAST WXSTRINGCAST
 224
 225 #endif
 226   // wxUSE_WCHAR_T
 227
 228 // ----------------------------------------------------------------------------
 229 // macros for the most common conversions
 230 // ----------------------------------------------------------------------------
 231
 232 #if wxUSE_UNICODE
 233     #define wxConvertWX2MB(s)   wxConvCurrent->cWX2MB(s)
 234     #define wxConvertMB2WX(s)   wxConvCurrent->cMB2WX(s)
 235 #else // ANSI
 236     // no conversions to do
 237     #define wxConvertWX2MB(s)   (s)
 238     #define wxConvertMB2WX(s)   (s)
 239 #endif // Unicode/ANSI
 240
 241 #endif
 242   // _WX_WXSTRCONVH__
 243