Debian Codegraph @

nx-X11/lib/src/imConv.c

raw
1 /******************************************************************
2
3 Copyright 1991, 1992 by Fuji Xerox Co.,Ltd.
4 Copyright 1993, 1994 by FUJITSU LIMITED
5
6 Permission to use, copy, modify, distribute, and sell this software
7 and its documentation for any purpose is hereby granted without fee,
8 provided that the above copyright notice appear in all copies and
9 that both that copyright notice and this permission notice appear
10 in supporting documentation, and that the name of Fuji Xerox Co.,Ltd.
11 , and that the name of FUJITSU LIMITED not be used in advertising or
12 publicity pertaining to distribution of the software without specific,
13 written prior permission.
14 Fuji Xerox Co.,Ltd. , and FUJITSU LIMITED makes no representations about
15 the suitability of this software for any purpose.
16 It is provided "as is" without express or implied warranty.
17
18 FUJI XEROX CO.,LTD. AND FUJITSU LIMITED DISCLAIMS ALL WARRANTIES WITH
19 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
20 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL FUJI XEROX CO.,LTD.
21 AND FUJITSU LIMITED BE LIABLE FOR ANY SPECIAL, INDIRECT
22 OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
23 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
24 NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
25 THE USE OR PERFORMANCE OF THIS SOFTWARE.
26
27 Author: Kazunori Nishihara, Fuji Xerox Co.,Ltd.
28 [email protected]
29 Modifier: Takashi Fujiwara FUJITSU LIMITED
30 [email protected]
31
32 ******************************************************************/
33 /* 2000 Modifier: Ivan Pascal The XFree86 Project.
34 */
35
36 #ifdef HAVE_CONFIG_H
37 #include <config.h>
38 #endif
39 #include <stdio.h>
40 #include "Xlibint.h"
41 #include "Xlcint.h"
42 #include "Ximint.h"
43 #include "XlcPubI.h"
44
45 #ifdef XKB
46 /*
47 * rather than just call _XLookupString (i.e. the pre-XKB XLookupString)
48 * do this because with XKB the event may have some funky modifiers that
49 * _XLookupString doesn't grok.
50 */
51 #include "XKBlib.h"
52 #define XLOOKUPSTRING lookup_string
53 #else
54 #define XLOOKUPSTRING XLookupString
55 #endif
56
57 typedef unsigned int ucs4_t;
58
59 typedef int (*ucstocsConvProc)(
60 XPointer,
61 unsigned char *,
62 ucs4_t,
63 int
64 );
65
66 struct SubstRec {
67 const char encoding_name[8];
68 const char charset_name[12];
69 };
70
71 static const struct SubstRec SubstTable[] = {
72 {"STRING", "ISO8859-1"},
73 {"TIS620", "TIS620-0"},
74 {"UTF-8", "ISO10646-1"}
75 };
76 #define num_substitute (sizeof SubstTable / sizeof SubstTable[0])
77
78 /*
79 * Given the name of a charset, returns the pointer to convertors
80 * from UCS char to specified charset char.
81 * This converter is needed for _XimGetCharCode subroutine.
82 */
83 XPointer
84 _XimGetLocaleCode (
85 _Xconst char* encoding_name)
86 {
87 XPointer cvt = _Utf8GetConvByName(encoding_name);
88 if (!cvt && encoding_name) {
89 int i;
90 for (i = 0; i < num_substitute; i++)
91 if (!strcmp(encoding_name, SubstTable[i].encoding_name))
92 return _Utf8GetConvByName(SubstTable[i].charset_name);
93 }
94 return cvt;
95 }
96
97 /*
98 * Returns the locale dependent representation of a keysym.
99 * The locale's encoding is passed in form of pointer to UCS converter.
100 * The resulting multi-byte sequence is placed starting at buf (a buffer
101 * with nbytes bytes, nbytes should be >= 8) and is NUL terminated.
102 * Returns the length of the resulting multi-byte sequence, excluding the
103 * terminating NUL byte. Return 0 if the keysym is not representable in the
104 * locale
105 */
106 /*ARGSUSED*/
107 int
108 _XimGetCharCode (
109 XPointer ucs_conv,
110 KeySym keysym,
111 unsigned char* buf,
112 int nbytes)
113 {
114 int count = 0;
115 ucstocsConvProc cvt = (ucstocsConvProc) ucs_conv;
116 ucs4_t ucs4;
117
118 if (keysym < 0x80) {
119 buf[0] = (char) keysym;
120 count = 1;
121 } else if (cvt) {
122 ucs4 = KeySymToUcs4(keysym);
123 if (ucs4)
124 count = (*cvt)((XPointer)NULL, buf, ucs4, nbytes);
125 }
126
127 if (count < 0)
128 count = 0;
129 if (count>nbytes)
130 return nbytes;
131 if (count<nbytes)
132 buf[count]= '\0';
133 return count;
134 }
135
136 #ifdef XKB
137 static int lookup_string(
138 XKeyEvent* event,
139 char* buffer,
140 int nbytes,
141 KeySym* keysym,
142 XComposeStatus* status)
143 {
144 int ret;
145 unsigned ctrls = XkbGetXlibControls (event->display);
146 XkbSetXlibControls (event->display,
147 XkbLC_ForceLatin1Lookup, XkbLC_ForceLatin1Lookup);
148 ret = XLookupString(event, (char *)buffer, nbytes, keysym, status);
149 XkbSetXlibControls (event->display,
150 XkbLC_ForceLatin1Lookup, ctrls);
151 return ret;
152 }
153 #endif
154
155 #define BUF_SIZE (20)
156
157 int
158 _XimLookupMBText(
159 Xic ic,
160 XKeyEvent* event,
161 char* buffer,
162 int nbytes,
163 KeySym* keysym,
164 XComposeStatus* status)
165 {
166 int count;
167 KeySym symbol;
168 Status dummy;
169 Xim im = (Xim)ic->core.im;
170 XimCommonPrivateRec* private = &im->private.common;
171 unsigned char look[BUF_SIZE];
172 ucs4_t ucs4;
173
174 /* force a latin-1 lookup for compatibility */
175 count = XLOOKUPSTRING(event, (char *)buffer, nbytes, &symbol, status);
176 if (keysym != NULL) *keysym = symbol;
177 if ((nbytes == 0) || (symbol == NoSymbol)) return count;
178
179 if (count > 1) {
180 memcpy(look, (char *)buffer,count);
181 look[count] = '\0';
182 if ((count = im->methods->ctstombs(ic->core.im,
183 (char*) look, count,
184 buffer, nbytes, &dummy)) < 0) {
185 count = 0;
186 }
187 } else if ((count == 0) ||
188 (count == 1 && (symbol > 0x7f && symbol < 0xff00))) {
189
190 XPointer from = (XPointer) &ucs4;
191 XPointer to = (XPointer) look;
192 int from_len = 1;
193 int to_len = BUF_SIZE;
194 XPointer args[1];
195 XlcCharSet charset;
196 args[0] = (XPointer) &charset;
197 ucs4 = (ucs4_t) KeySymToUcs4(symbol);
198 if (!ucs4)
199 return 0;
200
201 if (_XlcConvert(private->ucstoc_conv,
202 &from, &from_len, &to, &to_len,
203 args, 1 ) != 0) {
204 count = 0;
205 } else {
206 from = (XPointer) look;
207 to = (XPointer) buffer;
208 from_len = BUF_SIZE - to_len;
209 to_len = nbytes;
210 args[0] = (XPointer) charset;
211 if (_XlcConvert(private->cstomb_conv,
212 &from, &from_len, &to, &to_len,
213 args, 1 ) != 0) {
214 count = 0;
215 } else {
216 count = nbytes - to_len;
217 }
218 }
219 }
220 /* FIXME:
221 * we should make sure that if the character is a Latin1 character
222 * and it's on the right side, and we're in a non-Latin1 locale
223 * that this is a valid Latin1 character for this locale.
224 */
225 return count;
226 }
227
228 int
229 _XimLookupWCText(
230 Xic ic,
231 XKeyEvent* event,
232 wchar_t* buffer,
233 int nbytes,
234 KeySym* keysym,
235 XComposeStatus* status)
236 {
237 int count;
238 KeySym symbol;
239 Status dummy;
240 Xim im = (Xim)ic->core.im;
241 XimCommonPrivateRec* private = &im->private.common;
242 unsigned char look[BUF_SIZE];
243 ucs4_t ucs4;
244
245 /* force a latin-1 lookup for compatibility */
246 count = XLOOKUPSTRING(event, (char *)look, nbytes, &symbol, status);
247 if (keysym != NULL) *keysym = symbol;
248 if ((nbytes == 0) || (symbol == NoSymbol)) return count;
249
250 if (count > 1) {
251 if ((count = im->methods->ctstowcs(ic->core.im,
252 (char*) look, count,
253 buffer, nbytes, &dummy)) < 0) {
254 count = 0;
255 }
256 } else if ((count == 0) ||
257 (count == 1 && (symbol > 0x7f && symbol < 0xff00))) {
258
259 XPointer from = (XPointer) &ucs4;
260 XPointer to = (XPointer) look;
261 int from_len = 1;
262 int to_len = BUF_SIZE;
263 XPointer args[1];
264 XlcCharSet charset;
265 args[0] = (XPointer) &charset;
266 ucs4 = (ucs4_t) KeySymToUcs4(symbol);
267 if (!ucs4)
268 return 0;
269
270 if (_XlcConvert(private->ucstoc_conv,
271 &from, &from_len, &to, &to_len,
272 args, 1 ) != 0) {
273 count = 0;
274 } else {
275 from = (XPointer) look;
276 to = (XPointer) buffer;
277 from_len = BUF_SIZE - to_len;
278 to_len = nbytes;
279 args[0] = (XPointer) charset;
280
281 if (_XlcConvert(private->cstowc_conv,
282 &from, &from_len, &to, &to_len,
283 args, 1 ) != 0) {
284 count = 0;
285 } else {
286 count = nbytes - to_len;
287 }
288 }
289 } else
290 /* FIXME:
291 * we should make sure that if the character is a Latin1 character
292 * and it's on the right side, and we're in a non-Latin1 locale
293 * that this is a valid Latin1 character for this locale.
294 */
295 buffer[0] = look[0];
296
297 return count;
298 }
299
300 int
301 _XimLookupUTF8Text(
302 Xic ic,
303 XKeyEvent* event,
304 char* buffer,
305 int nbytes,
306 KeySym* keysym,
307 XComposeStatus* status)
308 {
309 int count;
310 KeySym symbol;
311 Status dummy;
312 Xim im = (Xim)ic->core.im;
313 XimCommonPrivateRec* private = &im->private.common;
314 unsigned char look[BUF_SIZE];
315 ucs4_t ucs4;
316
317 /* force a latin-1 lookup for compatibility */
318 count = XLOOKUPSTRING(event, (char *)buffer, nbytes, &symbol, status);
319 if (keysym != NULL) *keysym = symbol;
320 if ((nbytes == 0) || (symbol == NoSymbol)) return count;
321
322 if (count > 1) {
323 memcpy(look, (char *)buffer,count);
324 look[count] = '\0';
325 if ((count = im->methods->ctstoutf8(ic->core.im,
326 (char*) look, count,
327 buffer, nbytes, &dummy)) < 0) {
328 count = 0;
329 }
330 } else if ((count == 0) ||
331 (count == 1 && (symbol > 0x7f && symbol < 0xff00))) {
332
333 XPointer from = (XPointer) &ucs4;
334 int from_len = 1;
335 XPointer to = (XPointer) buffer;
336 int to_len = nbytes;
337
338 ucs4 = (ucs4_t) KeySymToUcs4(symbol);
339 if (!ucs4)
340 return 0;
341
342 if (_XlcConvert(private->ucstoutf8_conv,
343 &from, &from_len, &to, &to_len,
344 NULL, 0) != 0) {
345 count = 0;
346 } else {
347 count = nbytes - to_len;
348 }
349 }
350 /* FIXME:
351 * we should make sure that if the character is a Latin1 character
352 * and it's on the right side, and we're in a non-Latin1 locale
353 * that this is a valid Latin1 character for this locale.
354 */
355 return count;
356 }