1 /******************************************************************
2
3 Copyright 1994, 1995 by Sun Microsystems, Inc.
4 Copyright 1993, 1994 by Hewlett-Packard Company
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 Sun Microsystems, Inc.
11 and Hewlett-Packard not be used in advertising or publicity pertaining to
12 distribution of the software without specific, written prior permission.
13 Sun Microsystems, Inc. and Hewlett-Packard make no representations about
14 the suitability of this software for any purpose. It is provided "as is"
15 without express or implied warranty.
16
17 SUN MICROSYSTEMS INC. AND HEWLETT-PACKARD COMPANY DISCLAIMS ALL
18 WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED
19 WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
20 SUN MICROSYSTEMS, INC. AND HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY
21 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
22 RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
23 CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
24 IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
25
26 Author: Hidetoshi Tajima(tajima@Eng.Sun.COM) Sun Microsystems, Inc.
27
28 This version tidied and debugged by Steve Underwood May 1999
29
30 ******************************************************************/
31
32 #include <X11/Xlib.h>
33 #include "IMdkit.h"
34 #include "Xi18n.h"
35 #include "FrameMgr.h"
36 #include "XimFunc.h"
37
_Xi18nGeometryCallback(XIMS ims,IMProtocol * call_data)38 int _Xi18nGeometryCallback (XIMS ims, IMProtocol *call_data)
39 {
40 Xi18n i18n_core = ims->protocol;
41 FrameMgr fm;
42 extern XimFrameRec geometry_fr[];
43 register int total_size;
44 unsigned char *reply = NULL;
45 IMGeometryCBStruct *geometry_CB =
46 (IMGeometryCBStruct *) &call_data->geometry_callback;
47 CARD16 connect_id = call_data->any.connect_id;
48
49 fm = FrameMgrInit (geometry_fr,
50 NULL,
51 _Xi18nNeedSwap (i18n_core, connect_id));
52
53 total_size = FrameMgrGetTotalSize (fm);
54 reply = (unsigned char *) malloc (total_size);
55 if (!reply)
56 {
57 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
58 return False;
59 }
60 /*endif*/
61 memset (reply, 0, total_size);
62 FrameMgrSetBuffer (fm, reply);
63
64 FrameMgrPutToken (fm, connect_id);
65 FrameMgrPutToken (fm, geometry_CB->icid);
66
67 _Xi18nSendMessage (ims,
68 connect_id,
69 XIM_GEOMETRY,
70 0,
71 reply,
72 total_size);
73 FrameMgrFree (fm);
74 XFree (reply);
75
76 /* XIM_GEOMETRY is an asyncronous protocol,
77 so return immediately. */
78 return True;
79 }
80
_Xi18nPreeditStartCallback(XIMS ims,IMProtocol * call_data)81 int _Xi18nPreeditStartCallback (XIMS ims, IMProtocol *call_data)
82 {
83 Xi18n i18n_core = ims->protocol;
84 FrameMgr fm;
85 extern XimFrameRec preedit_start_fr[];
86 register int total_size;
87 unsigned char *reply = NULL;
88 IMPreeditCBStruct *preedit_CB =
89 (IMPreeditCBStruct*) &call_data->preedit_callback;
90 CARD16 connect_id = call_data->any.connect_id;
91
92 fm = FrameMgrInit (preedit_start_fr,
93 NULL,
94 _Xi18nNeedSwap (i18n_core, connect_id));
95 total_size = FrameMgrGetTotalSize (fm);
96 reply = (unsigned char *) malloc (total_size);
97 if (!reply)
98 {
99 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
100 return False;
101 }
102 /*endif*/
103 memset (reply, 0, total_size);
104 FrameMgrSetBuffer (fm, reply);
105
106 FrameMgrPutToken (fm, connect_id);
107 FrameMgrPutToken (fm, preedit_CB->icid);
108
109 _Xi18nSendMessage (ims,
110 connect_id,
111 XIM_PREEDIT_START,
112 0,
113 reply,
114 total_size);
115 FrameMgrFree (fm);
116 XFree (reply);
117
118 return True;
119 }
120
_Xi18nPreeditDrawCallback(XIMS ims,IMProtocol * call_data)121 int _Xi18nPreeditDrawCallback (XIMS ims, IMProtocol *call_data)
122 {
123 Xi18n i18n_core = ims->protocol;
124 FrameMgr fm;
125 extern XimFrameRec preedit_draw_fr[];
126 register int total_size;
127 unsigned char *reply = NULL;
128 IMPreeditCBStruct *preedit_CB =
129 (IMPreeditCBStruct *) &call_data->preedit_callback;
130 XIMPreeditDrawCallbackStruct *draw =
131 (XIMPreeditDrawCallbackStruct *) &preedit_CB->todo.draw;
132 CARD16 connect_id = call_data->any.connect_id;
133 register int feedback_count;
134 register int i;
135 BITMASK32 status = 0x0;
136
137 if (draw->text->length == 0)
138 status = 0x00000001;
139 else if (draw->text->feedback[0] == 0)
140 status = 0x00000002;
141 /*endif*/
142
143 fm = FrameMgrInit (preedit_draw_fr,
144 NULL,
145 _Xi18nNeedSwap (i18n_core, connect_id));
146
147 /* set length of preedit string */
148 FrameMgrSetSize (fm, draw->text->length);
149
150 /* set iteration count for list of feedback */
151 for (i = 0; draw->text->feedback[i] != 0; i++)
152 ;
153 /*endfor*/
154 feedback_count = i;
155 FrameMgrSetIterCount (fm, feedback_count);
156
157 total_size = FrameMgrGetTotalSize (fm);
158 reply = (unsigned char *) malloc (total_size);
159 if (!reply)
160 {
161 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
162 return False;
163 }
164 /*endif*/
165 memset (reply, 0, total_size);
166 FrameMgrSetBuffer (fm, reply);
167
168 FrameMgrPutToken (fm, connect_id);
169 FrameMgrPutToken (fm, preedit_CB->icid);
170 FrameMgrPutToken (fm, draw->caret);
171 FrameMgrPutToken (fm, draw->chg_first);
172 FrameMgrPutToken (fm, draw->chg_length);
173 FrameMgrPutToken (fm, status);
174 FrameMgrPutToken (fm, draw->text->length);
175 FrameMgrPutToken (fm, draw->text->string);
176 for (i = 0; i < feedback_count; i++)
177 FrameMgrPutToken (fm, draw->text->feedback[i]);
178 /*endfor*/
179
180 _Xi18nSendMessage (ims,
181 connect_id,
182 XIM_PREEDIT_DRAW,
183 0,
184 reply,
185 total_size);
186 FrameMgrFree (fm);
187 XFree (reply);
188
189 /* XIM_PREEDIT_DRAW is an asyncronous protocol, so return immediately. */
190 return True;
191 }
192
_Xi18nPreeditCaretCallback(XIMS ims,IMProtocol * call_data)193 int _Xi18nPreeditCaretCallback (XIMS ims, IMProtocol *call_data)
194 {
195 Xi18n i18n_core = ims->protocol;
196 FrameMgr fm;
197 extern XimFrameRec preedit_caret_fr[];
198 register int total_size;
199 unsigned char *reply = NULL;
200 IMPreeditCBStruct *preedit_CB =
201 (IMPreeditCBStruct*) &call_data->preedit_callback;
202 XIMPreeditCaretCallbackStruct *caret =
203 (XIMPreeditCaretCallbackStruct *) &preedit_CB->todo.caret;
204 CARD16 connect_id = call_data->any.connect_id;
205
206 fm = FrameMgrInit (preedit_caret_fr,
207 NULL,
208 _Xi18nNeedSwap (i18n_core, connect_id));
209
210 total_size = FrameMgrGetTotalSize (fm);
211 reply = (unsigned char *) malloc (total_size);
212 if (!reply)
213 {
214 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
215 return False;
216 }
217 /*endif*/
218 memset (reply, 0, total_size);
219 FrameMgrSetBuffer (fm, reply);
220
221 FrameMgrPutToken (fm, connect_id);
222 FrameMgrPutToken (fm, preedit_CB->icid);
223 FrameMgrPutToken (fm, caret->position);
224 FrameMgrPutToken (fm, caret->direction);
225 FrameMgrPutToken (fm, caret->style);
226
227 _Xi18nSendMessage (ims,
228 connect_id,
229 XIM_PREEDIT_CARET,
230 0,
231 reply,
232 total_size);
233 FrameMgrFree (fm);
234 XFree (reply);
235
236 return True;
237 }
238
_Xi18nPreeditDoneCallback(XIMS ims,IMProtocol * call_data)239 int _Xi18nPreeditDoneCallback (XIMS ims, IMProtocol *call_data)
240 {
241 Xi18n i18n_core = ims->protocol;
242 FrameMgr fm;
243 extern XimFrameRec preedit_done_fr[];
244 register int total_size;
245 unsigned char *reply = NULL;
246 IMPreeditCBStruct *preedit_CB =
247 (IMPreeditCBStruct *) &call_data->preedit_callback;
248 CARD16 connect_id = call_data->any.connect_id;
249
250 fm = FrameMgrInit (preedit_done_fr,
251 NULL,
252 _Xi18nNeedSwap (i18n_core, connect_id));
253
254 total_size = FrameMgrGetTotalSize (fm);
255 reply = (unsigned char *) malloc (total_size);
256 if (!reply)
257 {
258 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
259 return False;
260 }
261 /*endif*/
262 memset (reply, 0, total_size);
263 FrameMgrSetBuffer (fm, reply);
264
265 FrameMgrPutToken (fm, connect_id);
266 FrameMgrPutToken (fm, preedit_CB->icid);
267
268 _Xi18nSendMessage (ims,
269 connect_id,
270 XIM_PREEDIT_DONE,
271 0,
272 reply,
273 total_size);
274 FrameMgrFree (fm);
275 XFree (reply);
276
277 /* XIM_PREEDIT_DONE is an asyncronous protocol, so return immediately. */
278 return True;
279 }
280
_Xi18nStatusStartCallback(XIMS ims,IMProtocol * call_data)281 int _Xi18nStatusStartCallback (XIMS ims, IMProtocol *call_data)
282 {
283 Xi18n i18n_core = ims->protocol;
284 FrameMgr fm;
285 extern XimFrameRec status_start_fr[];
286 register int total_size;
287 unsigned char *reply = NULL;
288 IMStatusCBStruct *status_CB =
289 (IMStatusCBStruct*) &call_data->status_callback;
290 CARD16 connect_id = call_data->any.connect_id;
291
292 fm = FrameMgrInit (status_start_fr,
293 NULL,
294 _Xi18nNeedSwap (i18n_core, connect_id));
295 total_size = FrameMgrGetTotalSize (fm);
296 reply = (unsigned char *) malloc (total_size);
297 if (!reply)
298 {
299 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
300 return False;
301 }
302 /*endif*/
303 memset (reply, 0, total_size);
304 FrameMgrSetBuffer (fm, reply);
305
306 FrameMgrPutToken (fm, connect_id);
307 FrameMgrPutToken (fm, status_CB->icid);
308
309 _Xi18nSendMessage (ims,
310 connect_id,
311 XIM_STATUS_START,
312 0,
313 reply,
314 total_size);
315 FrameMgrFree (fm);
316 XFree (reply);
317
318 /* XIM_STATUS_START is an asyncronous protocol, so return immediately. */
319 return True;
320 }
321
_Xi18nStatusDrawCallback(XIMS ims,IMProtocol * call_data)322 int _Xi18nStatusDrawCallback (XIMS ims, IMProtocol *call_data)
323 {
324 Xi18n i18n_core = ims->protocol;
325 FrameMgr fm = (FrameMgr)0;
326 extern XimFrameRec status_draw_text_fr[];
327 extern XimFrameRec status_draw_bitmap_fr[];
328 register int total_size = 0;
329 unsigned char *reply = NULL;
330 IMStatusCBStruct *status_CB =
331 (IMStatusCBStruct *) &call_data->status_callback;
332 XIMStatusDrawCallbackStruct *draw =
333 (XIMStatusDrawCallbackStruct *) &status_CB->todo.draw;
334 CARD16 connect_id = call_data->any.connect_id;
335 register int feedback_count;
336 register int i;
337 BITMASK32 status = 0x0;
338
339 switch (draw->type)
340 {
341 case XIMTextType:
342 fm = FrameMgrInit (status_draw_text_fr,
343 NULL,
344 _Xi18nNeedSwap (i18n_core, connect_id));
345
346 if (draw->data.text->length == 0)
347 status = 0x00000001;
348 else if (draw->data.text->feedback[0] == 0)
349 status = 0x00000002;
350 /*endif*/
351
352 /* set length of status string */
353 FrameMgrSetSize(fm, draw->data.text->length);
354 /* set iteration count for list of feedback */
355 for (i = 0; draw->data.text->feedback[i] != 0; i++)
356 ;
357 /*endfor*/
358 feedback_count = i;
359 FrameMgrSetIterCount (fm, feedback_count);
360
361 total_size = FrameMgrGetTotalSize (fm);
362 reply = (unsigned char *) malloc (total_size);
363 if (!reply)
364 {
365 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
366 return False;
367 }
368 /*endif*/
369 memset (reply, 0, total_size);
370 FrameMgrSetBuffer (fm, reply);
371
372 FrameMgrPutToken (fm, connect_id);
373 FrameMgrPutToken (fm, status_CB->icid);
374 FrameMgrPutToken (fm, draw->type);
375 FrameMgrPutToken (fm, status);
376 FrameMgrPutToken (fm, draw->data.text->length);
377 FrameMgrPutToken (fm, draw->data.text->string);
378 for (i = 0; i < feedback_count; i++)
379 FrameMgrPutToken (fm, draw->data.text->feedback[i]);
380 /*endfor*/
381 break;
382
383 case XIMBitmapType:
384 fm = FrameMgrInit (status_draw_bitmap_fr,
385 NULL,
386 _Xi18nNeedSwap (i18n_core, connect_id));
387
388 total_size = FrameMgrGetTotalSize (fm);
389 reply = (unsigned char *) malloc (total_size);
390 if (!reply)
391 {
392 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
393 return False;
394 }
395 /*endif*/
396 memset (reply, 0, total_size);
397 FrameMgrSetBuffer (fm, reply);
398
399 FrameMgrPutToken (fm, connect_id);
400 FrameMgrPutToken (fm, status_CB->icid);
401 FrameMgrPutToken (fm, draw->data.bitmap);
402 break;
403 }
404 /*endswitch*/
405 _Xi18nSendMessage (ims,
406 connect_id,
407 XIM_STATUS_DRAW,
408 0,
409 reply,
410 total_size);
411 FrameMgrFree (fm);
412 XFree (reply);
413
414 /* XIM_STATUS_DRAW is an asyncronous protocol, so return immediately. */
415 return True;
416 }
417
_Xi18nStatusDoneCallback(XIMS ims,IMProtocol * call_data)418 int _Xi18nStatusDoneCallback (XIMS ims, IMProtocol *call_data)
419 {
420 Xi18n i18n_core = ims->protocol;
421 FrameMgr fm;
422 extern XimFrameRec status_done_fr[];
423 register int total_size;
424 unsigned char *reply = NULL;
425 IMStatusCBStruct *status_CB =
426 (IMStatusCBStruct *) &call_data->status_callback;
427 CARD16 connect_id = call_data->any.connect_id;
428
429 fm = FrameMgrInit (status_done_fr,
430 NULL,
431 _Xi18nNeedSwap (i18n_core, connect_id));
432
433 total_size = FrameMgrGetTotalSize (fm);
434 reply = (unsigned char *) malloc (total_size);
435 if (!reply)
436 {
437 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
438 return False;
439 }
440 /*endif*/
441 memset (reply, 0, total_size);
442 FrameMgrSetBuffer (fm, reply);
443
444 FrameMgrPutToken (fm, connect_id);
445 FrameMgrPutToken (fm, status_CB->icid);
446
447 _Xi18nSendMessage (ims,
448 connect_id,
449 XIM_STATUS_DONE,
450 0,
451 reply,
452 total_size);
453 FrameMgrFree (fm);
454 XFree (reply);
455
456 /* XIM_STATUS_DONE is an asyncronous protocol, so return immediately. */
457 return True;
458 }
459
_Xi18nStringConversionCallback(XIMS ims,IMProtocol * call_data)460 int _Xi18nStringConversionCallback (XIMS ims, IMProtocol *call_data)
461 {
462 Xi18n i18n_core = ims->protocol;
463 FrameMgr fm;
464 extern XimFrameRec str_conversion_fr[];
465 register int total_size;
466 unsigned char *reply = NULL;
467 IMStrConvCBStruct *call_back =
468 (IMStrConvCBStruct *) &call_data->strconv_callback;
469 XIMStringConversionCallbackStruct *strconv =
470 (XIMStringConversionCallbackStruct *) &call_back->strconv;
471 CARD16 connect_id = call_data->any.connect_id;
472
473 fm = FrameMgrInit (str_conversion_fr,
474 NULL,
475 _Xi18nNeedSwap (i18n_core, connect_id));
476 #if 0
477 /* set length of preedit string */
478 FrameMgrSetSize (fm, strconv->text->length);
479 #endif
480 total_size = FrameMgrGetTotalSize (fm);
481 reply = (unsigned char *) malloc (total_size);
482 if (!reply)
483 {
484 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
485 return False;
486 }
487 /*endif*/
488 memset (reply, 0, total_size);
489 FrameMgrSetBuffer (fm, reply);
490
491 FrameMgrPutToken (fm, connect_id);
492 FrameMgrPutToken (fm, call_back->icid);
493 FrameMgrPutToken (fm, strconv->position);
494 FrameMgrPutToken (fm, strconv->direction);
495 FrameMgrPutToken (fm, strconv->operation);
496 #if 0
497 FrameMgrPutToken (fm, strconv->text->string);
498 #endif
499 _Xi18nSendMessage (ims, connect_id,
500 XIM_STR_CONVERSION,
501 0,
502 reply,
503 total_size);
504 FrameMgrFree (fm);
505 XFree (reply);
506
507 /* XIM_STR_CONVERSION is a syncronous protocol,
508 so should wait here for XIM_STR_CONVERSION_REPLY. */
509 if (i18n_core->methods.wait (ims,
510 connect_id,
511 XIM_STR_CONVERSION_REPLY,
512 0) == False)
513 {
514 return False;
515 }
516 /*endif*/
517 return True;
518 }
519