]> git.saurik.com Git - wxWidgets.git/blob - include/wx/chartype.h
Fixed context menu in wxRichTextCtrl
[wxWidgets.git] / include / wx / chartype.h
1 /*
2 * Name: wx/chartype.h
3 * Purpose: Declarations of wxChar and related types
4 * Author: Joel Farley, Ove Kåven
5 * Modified by: Vadim Zeitlin, Robert Roebling, Ron Lee
6 * Created: 1998/06/12
7 * RCS-ID: $Id$
8 * Copyright: (c) 1998-2006 wxWidgets dev team
9 * Licence: wxWindows licence
10 */
11
12 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
13
14 #ifndef _WX_WXCHARTYPE_H_
15 #define _WX_WXCHARTYPE_H_
16
17 /* defs.h indirectly includes this file, so don't include it here */
18 #include "wx/platform.h"
19
20 /* check whether we have wchar_t and which size it is if we do */
21 #if !defined(wxUSE_WCHAR_T)
22 #if defined(__UNIX__)
23 #if defined(HAVE_WCSTR_H) || defined(HAVE_WCHAR_H) || defined(__FreeBSD__) || defined(__DARWIN__)
24 #define wxUSE_WCHAR_T 1
25 #else
26 #define wxUSE_WCHAR_T 0
27 #endif
28 #elif defined(__GNUWIN32__) && !defined(__MINGW32__)
29 #define wxUSE_WCHAR_T 0
30 #elif defined(__WATCOMC__)
31 #define wxUSE_WCHAR_T 0
32 #elif defined(__VISAGECPP__) && (__IBMCPP__ < 400)
33 #define wxUSE_WCHAR_T 0
34 #else
35 /* add additional compiler checks if this fails */
36 #define wxUSE_WCHAR_T 1
37 #endif
38 #endif /* !defined(wxUSE_WCHAR_T) */
39
40 /* Unicode support requires wchar_t */
41 #if wxUSE_UNICODE && !wxUSE_WCHAR_T
42 #error "wchar_t must be available in Unicode build"
43 #endif /* Unicode */
44
45 /*
46 non Unix compilers which do have wchar.h (but not tchar.h which is included
47 below and which includes wchar.h anyhow).
48
49 Actually MinGW has tchar.h, but it does not include wchar.h
50 */
51 #if defined(__MWERKS__) || defined(__VISAGECPP__) || defined(__MINGW32__) || defined(__WATCOMC__)
52 #ifndef HAVE_WCHAR_H
53 #define HAVE_WCHAR_H
54 #endif
55 #endif
56 #if defined(__MWERKS__) && !defined(__MACH__)
57 #ifndef HAVE_WCSLEN
58 #define HAVE_WCSLEN
59 #endif
60 #endif
61
62 #if wxUSE_WCHAR_T
63 #ifdef HAVE_WCHAR_H
64 /* the current (as of Nov 2002) version of cygwin has a bug in its */
65 /* wchar.h -- there is no extern "C" around the declarations in it */
66 /* and this results in linking errors later; also, at least on some */
67 /* Cygwin versions, wchar.h requires sys/types.h */
68 #ifdef __CYGWIN__
69 #include <sys/types.h>
70 #ifdef __cplusplus
71 extern "C" {
72 #endif
73 #endif /* Cygwin */
74
75 #include <wchar.h>
76
77 #if defined(__CYGWIN__) && defined(__cplusplus)
78 }
79 #endif /* Cygwin and C++ */
80
81 #elif defined(HAVE_WCSTR_H)
82 /* old compilers have relevant declarations here */
83 #include <wcstr.h>
84 #elif defined(__FreeBSD__) || defined(__DARWIN__) || defined(__EMX__)
85 /* include stdlib.h for wchar_t */
86 #include <stdlib.h>
87 #endif /* HAVE_WCHAR_H */
88
89 #ifdef HAVE_WIDEC_H
90 #include <widec.h>
91 #endif
92 #endif /* wxUSE_WCHAR_T */
93
94 /* -------------------------------------------------------------------------- */
95 /* define wxHAVE_TCHAR_SUPPORT for the compilers which support the TCHAR type */
96 /* mapped to either char or wchar_t depending on the ASCII/Unicode mode and */
97 /* have the function mapping _tfoo() -> foo() or wfoo() */
98 /* -------------------------------------------------------------------------- */
99
100 /* VC++ and BC++ starting with 5.2 have TCHAR support */
101 #ifdef __VISUALC__
102 #define wxHAVE_TCHAR_SUPPORT
103 #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x520)
104 #define wxHAVE_TCHAR_SUPPORT
105 #include <ctype.h>
106 #elif defined(__WATCOMC__)
107 #define wxHAVE_TCHAR_SUPPORT
108 #elif defined(__DMC__)
109 #define wxHAVE_TCHAR_SUPPORT
110 #elif defined(__WXPALMOS__)
111 #include <stddef.h>
112 #elif defined(__MINGW32__) && wxCHECK_W32API_VERSION( 1, 0 )
113 #define wxHAVE_TCHAR_SUPPORT
114 #include <stddef.h>
115 #include <string.h>
116 #include <ctype.h>
117 #elif 0 && defined(__VISAGECPP__) && (__IBMCPP__ >= 400)
118 /* VZ: the old VisualAge definitions were completely wrong and had no */
119 /* chance at all to work in Unicode build anyhow so let's pretend */
120 /* that VisualAge does _not_ support TCHAR for the moment (as */
121 /* indicated by "0 &&" above) until someone really has time to delve */
122 /* into Unicode issues under OS/2 */
123
124 /* VisualAge 4.0+ supports TCHAR */
125 #define wxHAVE_TCHAR_SUPPORT
126 #endif /* compilers with (good) TCHAR support */
127
128 #ifdef wxHAVE_TCHAR_SUPPORT
129 /* get TCHAR definition if we've got it */
130 #include <tchar.h>
131
132 /* we surely do have wchar_t if we have TCHAR */
133 #ifndef wxUSE_WCHAR_T
134 #define wxUSE_WCHAR_T 1
135 #endif /* !defined(wxUSE_WCHAR_T) */
136 #endif /* wxHAVE_TCHAR_SUPPORT */
137
138 /* ------------------------------------------------------------------------- */
139 /* define wxChar type */
140 /* ------------------------------------------------------------------------- */
141
142 /* TODO: define wxCharInt to be equal to either int or wint_t? */
143
144 #if !wxUSE_UNICODE
145 typedef char wxChar;
146 typedef signed char wxSChar;
147 typedef unsigned char wxUChar;
148 #else /* Unicode */
149 /* VZ: note that VC++ defines _T[SU]CHAR simply as wchar_t and not as */
150 /* signed/unsigned version of it which (a) makes sense to me (unlike */
151 /* char wchar_t is always unsigned) and (b) was how the previous */
152 /* definitions worked so keep it like this */
153
154 /* Sun's SunPro compiler supports the wchar_t type and wide character */
155 /* functions, but does not define __WCHAR_TYPE__. Define it here to */
156 /* allow unicode enabled builds. */
157 #if (defined(__SUNPRO_CC) || defined(__SUNPRO_C)) && !defined(__WCHAR_TYPE__)
158 #define __WCHAR_TYPE__ wxchar_t
159 #endif
160
161 /* GNU libc has __WCHAR_TYPE__ which requires special treatment, see */
162 /* comment below */
163 #if !defined(__WCHAR_TYPE__) || \
164 (!defined(__GNUC__) || wxCHECK_GCC_VERSION(2, 96))
165 /* standard case */
166 typedef wchar_t wxChar;
167 typedef wchar_t wxSChar;
168 typedef wchar_t wxUChar;
169 #else /* __WCHAR_TYPE__ and gcc < 2.96 */
170 /* VS: wxWidgets used to define wxChar as __WCHAR_TYPE__ here. */
171 /* However, this doesn't work with new GCC 3.x compilers because */
172 /* wchar_t is C++'s builtin type in the new standard. OTOH, old */
173 /* compilers (GCC 2.x) won't accept new definition of */
174 /* wx{S,U}CharType, so we have to define wxChar */
175 /* conditionally depending on detected compiler & compiler */
176 /* version. */
177
178 /* with old definition of wxChar. */
179 #define wchar_t __WCHAR_TYPE__
180 typedef __WCHAR_TYPE__ wxChar;
181 typedef __WCHAR_TYPE__ wxSChar;
182 typedef __WCHAR_TYPE__ wxUChar;
183 #endif /* __WCHAR_TYPE__ */
184 #endif /* ASCII/Unicode */
185
186 /* ------------------------------------------------------------------------- */
187 /* define wxStringCharType */
188 /* ------------------------------------------------------------------------- */
189
190 /* depending on the platform, Unicode build can either store wxStrings as
191 wchar_t* or UTF-8 encoded char*: */
192 #if wxUSE_UNICODE
193 /* FIXME-UTF8: what would be better place for this? */
194 #if defined(wxUSE_UTF8_LOCALE_ONLY) && !defined(wxUSE_UNICODE_UTF8)
195 #error "wxUSE_UTF8_LOCALE_ONLY only makes sense with wxUSE_UNICODE_UTF8"
196 #endif
197 #ifndef wxUSE_UTF8_LOCALE_ONLY
198 #define wxUSE_UTF8_LOCALE_ONLY 0
199 #endif
200
201 #ifndef wxUSE_UNICODE_UTF8
202 #define wxUSE_UNICODE_UTF8 0
203 #endif
204
205 #if wxUSE_UNICODE_UTF8
206 #define wxUSE_UNICODE_WCHAR 0
207 #else
208 #define wxUSE_UNICODE_WCHAR 1
209 #endif
210 #else
211 #define wxUSE_UNICODE_WCHAR 0
212 #define wxUSE_UNICODE_UTF8 0
213 #define wxUSE_UTF8_LOCALE_ONLY 0
214 #endif
215
216 /* define char type used by wxString internal representation: */
217 #if wxUSE_UNICODE_UTF8
218 typedef char wxStringCharType;
219 #elif wxUSE_UNICODE_WCHAR
220 typedef wchar_t wxStringCharType;
221 #else
222 typedef char wxStringCharType;
223 #endif
224
225
226 /* ------------------------------------------------------------------------- */
227 /* define _T() and related macros */
228 /* ------------------------------------------------------------------------- */
229
230 /* BSD systems define _T() to be something different in ctype.h, override it */
231 #if defined(__FreeBSD__) || defined(__DARWIN__)
232 #include <ctype.h>
233 #undef _T
234 #endif
235
236 /* could already be defined by tchar.h (it's quasi standard) */
237 #ifndef _T
238 #if !wxUSE_UNICODE
239 #define _T(x) x
240 #else /* Unicode */
241 /* use wxCONCAT_HELPER so that x could be expanded if it's a macro */
242 #define _T(x) wxCONCAT_HELPER(L, x)
243 #endif /* ASCII/Unicode */
244 #endif /* !defined(_T) */
245
246 /* although global macros with such names are normally bad, we want to have */
247 /* another name for _T() which should be used to avoid confusion between */
248 /* _T() and _() in wxWidgets sources */
249 #define wxT(x) _T(x)
250
251 /* a helper macro allowing to make another macro Unicode-friendly, see below */
252 #define wxAPPLY_T(x) _T(x)
253
254 /* Unicode-friendly __FILE__, __DATE__ and __TIME__ analogs */
255 #ifndef __TFILE__
256 #define __TFILE__ wxAPPLY_T(__FILE__)
257 #endif
258
259 #ifndef __TDATE__
260 #define __TDATE__ wxAPPLY_T(__DATE__)
261 #endif
262
263 #ifndef __TTIME__
264 #define __TTIME__ wxAPPLY_T(__TIME__)
265 #endif
266
267 #endif /* _WX_WXCHARTYPE_H_ */
268