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 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
57 return False;
58 }
59 /*endif*/
60 memset(reply, 0, total_size);
61 FrameMgrSetBuffer(fm, reply);
62
63 FrameMgrPutToken(fm, connect_id);
64 FrameMgrPutToken(fm, geometry_CB->icid);
65
66 _Xi18nSendMessage(ims,
67 connect_id,
68 XIM_GEOMETRY,
69 0,
70 reply,
71 total_size);
72 FrameMgrFree(fm);
73 XFree(reply);
74
75 /* XIM_GEOMETRY is an asyncronous protocol,
76 so return immediately. */
77 return True;
78 }
79
_Xi18nPreeditStartCallback(XIMS ims,IMProtocol * call_data)80 int _Xi18nPreeditStartCallback(XIMS ims, IMProtocol *call_data)
81 {
82 Xi18n i18n_core = ims->protocol;
83 FrameMgr fm;
84 extern XimFrameRec preedit_start_fr[];
85 register int total_size;
86 unsigned char *reply = NULL;
87 IMPreeditCBStruct *preedit_CB =
88 (IMPreeditCBStruct*) &call_data->preedit_callback;
89 CARD16 connect_id = call_data->any.connect_id;
90
91 fm = FrameMgrInit(preedit_start_fr,
92 NULL,
93 _Xi18nNeedSwap(i18n_core, connect_id));
94 total_size = FrameMgrGetTotalSize(fm);
95 reply = (unsigned char *) malloc(total_size);
96 if (!reply) {
97 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
98 return False;
99 }
100 /*endif*/
101 memset(reply, 0, total_size);
102 FrameMgrSetBuffer(fm, reply);
103
104 FrameMgrPutToken(fm, connect_id);
105 FrameMgrPutToken(fm, preedit_CB->icid);
106
107 _Xi18nSendMessage(ims,
108 connect_id,
109 XIM_PREEDIT_START,
110 0,
111 reply,
112 total_size);
113 FrameMgrFree(fm);
114 XFree(reply);
115
116 return True;
117 }
118
_Xi18nPreeditDrawCallback(XIMS ims,IMProtocol * call_data)119 int _Xi18nPreeditDrawCallback(XIMS ims, IMProtocol *call_data)
120 {
121 Xi18n i18n_core = ims->protocol;
122 FrameMgr fm;
123 extern XimFrameRec preedit_draw_fr[];
124 register int total_size;
125 unsigned char *reply = NULL;
126 IMPreeditCBStruct *preedit_CB =
127 (IMPreeditCBStruct *) &call_data->preedit_callback;
128 XIMPreeditDrawCallbackStruct *draw =
129 (XIMPreeditDrawCallbackStruct *) &preedit_CB->todo.draw;
130 CARD16 connect_id = call_data->any.connect_id;
131 register int feedback_count;
132 register int i;
133 BITMASK32 status = 0x0;
134
135 if (draw->text->length == 0)
136 status = 0x00000001;
137 else if (draw->text->feedback[0] == 0)
138 status = 0x00000002;
139 /*endif*/
140
141 fm = FrameMgrInit(preedit_draw_fr,
142 NULL,
143 _Xi18nNeedSwap(i18n_core, connect_id));
144
145 /* set length of preedit string */
146 FrameMgrSetSize(fm, draw->text->length);
147
148 /* set iteration count for list of feedback */
149 for (i = 0; draw->text->feedback[i] != 0; i++)
150 ;
151 /*endfor*/
152 feedback_count = i;
153 FrameMgrSetIterCount(fm, feedback_count);
154
155 total_size = FrameMgrGetTotalSize(fm);
156 reply = (unsigned char *) malloc(total_size);
157 if (!reply) {
158 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
159 return False;
160 }
161 /*endif*/
162 memset(reply, 0, total_size);
163 FrameMgrSetBuffer(fm, reply);
164
165 FrameMgrPutToken(fm, connect_id);
166 FrameMgrPutToken(fm, preedit_CB->icid);
167 FrameMgrPutToken(fm, draw->caret);
168 FrameMgrPutToken(fm, draw->chg_first);
169 FrameMgrPutToken(fm, draw->chg_length);
170 FrameMgrPutToken(fm, status);
171 FrameMgrPutToken(fm, draw->text->length);
172 FrameMgrPutToken(fm, draw->text->string);
173 for (i = 0; i < feedback_count; i++)
174 FrameMgrPutToken(fm, draw->text->feedback[i]);
175 /*endfor*/
176
177 _Xi18nSendMessage(ims,
178 connect_id,
179 XIM_PREEDIT_DRAW,
180 0,
181 reply,
182 total_size);
183 FrameMgrFree(fm);
184 XFree(reply);
185
186 /* XIM_PREEDIT_DRAW is an asyncronous protocol, so return immediately. */
187 return True;
188 }
189
_Xi18nPreeditCaretCallback(XIMS ims,IMProtocol * call_data)190 int _Xi18nPreeditCaretCallback(XIMS ims, IMProtocol *call_data)
191 {
192 Xi18n i18n_core = ims->protocol;
193 FrameMgr fm;
194 extern XimFrameRec preedit_caret_fr[];
195 register int total_size;
196 unsigned char *reply = NULL;
197 IMPreeditCBStruct *preedit_CB =
198 (IMPreeditCBStruct*) &call_data->preedit_callback;
199 XIMPreeditCaretCallbackStruct *caret =
200 (XIMPreeditCaretCallbackStruct *) &preedit_CB->todo.caret;
201 CARD16 connect_id = call_data->any.connect_id;
202
203 fm = FrameMgrInit(preedit_caret_fr,
204 NULL,
205 _Xi18nNeedSwap(i18n_core, connect_id));
206
207 total_size = FrameMgrGetTotalSize(fm);
208 reply = (unsigned char *) malloc(total_size);
209 if (!reply) {
210 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
211 return False;
212 }
213 /*endif*/
214 memset(reply, 0, total_size);
215 FrameMgrSetBuffer(fm, reply);
216
217 FrameMgrPutToken(fm, connect_id);
218 FrameMgrPutToken(fm, preedit_CB->icid);
219 FrameMgrPutToken(fm, caret->position);
220 FrameMgrPutToken(fm, caret->direction);
221 FrameMgrPutToken(fm, caret->style);
222
223 _Xi18nSendMessage(ims,
224 connect_id,
225 XIM_PREEDIT_CARET,
226 0,
227 reply,
228 total_size);
229 FrameMgrFree(fm);
230 XFree(reply);
231
232 return True;
233 }
234
_Xi18nPreeditDoneCallback(XIMS ims,IMProtocol * call_data)235 int _Xi18nPreeditDoneCallback(XIMS ims, IMProtocol *call_data)
236 {
237 Xi18n i18n_core = ims->protocol;
238 FrameMgr fm;
239 extern XimFrameRec preedit_done_fr[];
240 register int total_size;
241 unsigned char *reply = NULL;
242 IMPreeditCBStruct *preedit_CB =
243 (IMPreeditCBStruct *) &call_data->preedit_callback;
244 CARD16 connect_id = call_data->any.connect_id;
245
246 fm = FrameMgrInit(preedit_done_fr,
247 NULL,
248 _Xi18nNeedSwap(i18n_core, connect_id));
249
250 total_size = FrameMgrGetTotalSize(fm);
251 reply = (unsigned char *) malloc(total_size);
252 if (!reply) {
253 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
254 return False;
255 }
256 /*endif*/
257 memset(reply, 0, total_size);
258 FrameMgrSetBuffer(fm, reply);
259
260 FrameMgrPutToken(fm, connect_id);
261 FrameMgrPutToken(fm, preedit_CB->icid);
262
263 _Xi18nSendMessage(ims,
264 connect_id,
265 XIM_PREEDIT_DONE,
266 0,
267 reply,
268 total_size);
269 FrameMgrFree(fm);
270 XFree(reply);
271
272 /* XIM_PREEDIT_DONE is an asyncronous protocol, so return immediately. */
273 return True;
274 }
275
_Xi18nStatusStartCallback(XIMS ims,IMProtocol * call_data)276 int _Xi18nStatusStartCallback(XIMS ims, IMProtocol *call_data)
277 {
278 Xi18n i18n_core = ims->protocol;
279 FrameMgr fm;
280 extern XimFrameRec status_start_fr[];
281 register int total_size;
282 unsigned char *reply = NULL;
283 IMStatusCBStruct *status_CB =
284 (IMStatusCBStruct*) &call_data->status_callback;
285 CARD16 connect_id = call_data->any.connect_id;
286
287 fm = FrameMgrInit(status_start_fr,
288 NULL,
289 _Xi18nNeedSwap(i18n_core, connect_id));
290 total_size = FrameMgrGetTotalSize(fm);
291 reply = (unsigned char *) malloc(total_size);
292 if (!reply) {
293 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
294 return False;
295 }
296 /*endif*/
297 memset(reply, 0, total_size);
298 FrameMgrSetBuffer(fm, reply);
299
300 FrameMgrPutToken(fm, connect_id);
301 FrameMgrPutToken(fm, status_CB->icid);
302
303 _Xi18nSendMessage(ims,
304 connect_id,
305 XIM_STATUS_START,
306 0,
307 reply,
308 total_size);
309 FrameMgrFree(fm);
310 XFree(reply);
311
312 /* XIM_STATUS_START is an asyncronous protocol, so return immediately. */
313 return True;
314 }
315
_Xi18nStatusDrawCallback(XIMS ims,IMProtocol * call_data)316 int _Xi18nStatusDrawCallback(XIMS ims, IMProtocol *call_data)
317 {
318 Xi18n i18n_core = ims->protocol;
319 FrameMgr fm = (FrameMgr)0;
320 extern XimFrameRec status_draw_text_fr[];
321 extern XimFrameRec status_draw_bitmap_fr[];
322 register int total_size = 0;
323 unsigned char *reply = NULL;
324 IMStatusCBStruct *status_CB =
325 (IMStatusCBStruct *) &call_data->status_callback;
326 XIMStatusDrawCallbackStruct *draw =
327 (XIMStatusDrawCallbackStruct *) &status_CB->todo.draw;
328 CARD16 connect_id = call_data->any.connect_id;
329 register int feedback_count;
330 register int i;
331 BITMASK32 status = 0x0;
332
333 switch (draw->type) {
334 case XIMTextType:
335 fm = FrameMgrInit(status_draw_text_fr,
336 NULL,
337 _Xi18nNeedSwap(i18n_core, connect_id));
338
339 if (draw->data.text->length == 0)
340 status = 0x00000001;
341 else if (draw->data.text->feedback[0] == 0)
342 status = 0x00000002;
343 /*endif*/
344
345 /* set length of status string */
346 FrameMgrSetSize(fm, draw->data.text->length);
347 /* set iteration count for list of feedback */
348 for (i = 0; draw->data.text->feedback[i] != 0; i++)
349 ;
350 /*endfor*/
351 feedback_count = i;
352 FrameMgrSetIterCount(fm, feedback_count);
353
354 total_size = FrameMgrGetTotalSize(fm);
355 reply = (unsigned char *) malloc(total_size);
356 if (!reply) {
357 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
358 return False;
359 }
360 /*endif*/
361 memset(reply, 0, total_size);
362 FrameMgrSetBuffer(fm, reply);
363
364 FrameMgrPutToken(fm, connect_id);
365 FrameMgrPutToken(fm, status_CB->icid);
366 FrameMgrPutToken(fm, draw->type);
367 FrameMgrPutToken(fm, status);
368 FrameMgrPutToken(fm, draw->data.text->length);
369 FrameMgrPutToken(fm, draw->data.text->string);
370 for (i = 0; i < feedback_count; i++)
371 FrameMgrPutToken(fm, draw->data.text->feedback[i]);
372 /*endfor*/
373 break;
374
375 case XIMBitmapType:
376 fm = FrameMgrInit(status_draw_bitmap_fr,
377 NULL,
378 _Xi18nNeedSwap(i18n_core, connect_id));
379
380 total_size = FrameMgrGetTotalSize(fm);
381 reply = (unsigned char *) malloc(total_size);
382 if (!reply) {
383 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
384 return False;
385 }
386 /*endif*/
387 memset(reply, 0, total_size);
388 FrameMgrSetBuffer(fm, reply);
389
390 FrameMgrPutToken(fm, connect_id);
391 FrameMgrPutToken(fm, status_CB->icid);
392 FrameMgrPutToken(fm, draw->data.bitmap);
393 break;
394 }
395 /*endswitch*/
396 _Xi18nSendMessage(ims,
397 connect_id,
398 XIM_STATUS_DRAW,
399 0,
400 reply,
401 total_size);
402 FrameMgrFree(fm);
403 XFree(reply);
404
405 /* XIM_STATUS_DRAW is an asyncronous protocol, so return immediately. */
406 return True;
407 }
408
_Xi18nStatusDoneCallback(XIMS ims,IMProtocol * call_data)409 int _Xi18nStatusDoneCallback(XIMS ims, IMProtocol *call_data)
410 {
411 Xi18n i18n_core = ims->protocol;
412 FrameMgr fm;
413 extern XimFrameRec status_done_fr[];
414 register int total_size;
415 unsigned char *reply = NULL;
416 IMStatusCBStruct *status_CB =
417 (IMStatusCBStruct *) &call_data->status_callback;
418 CARD16 connect_id = call_data->any.connect_id;
419
420 fm = FrameMgrInit(status_done_fr,
421 NULL,
422 _Xi18nNeedSwap(i18n_core, connect_id));
423
424 total_size = FrameMgrGetTotalSize(fm);
425 reply = (unsigned char *) malloc(total_size);
426 if (!reply) {
427 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
428 return False;
429 }
430 /*endif*/
431 memset(reply, 0, total_size);
432 FrameMgrSetBuffer(fm, reply);
433
434 FrameMgrPutToken(fm, connect_id);
435 FrameMgrPutToken(fm, status_CB->icid);
436
437 _Xi18nSendMessage(ims,
438 connect_id,
439 XIM_STATUS_DONE,
440 0,
441 reply,
442 total_size);
443 FrameMgrFree(fm);
444 XFree(reply);
445
446 /* XIM_STATUS_DONE is an asyncronous protocol, so return immediately. */
447 return True;
448 }
449
_Xi18nStringConversionCallback(XIMS ims,IMProtocol * call_data)450 int _Xi18nStringConversionCallback(XIMS ims, IMProtocol *call_data)
451 {
452 Xi18n i18n_core = ims->protocol;
453 FrameMgr fm;
454 extern XimFrameRec str_conversion_fr[];
455 register int total_size;
456 unsigned char *reply = NULL;
457 IMStrConvCBStruct *call_back =
458 (IMStrConvCBStruct *) &call_data->strconv_callback;
459 XIMStringConversionCallbackStruct *strconv =
460 (XIMStringConversionCallbackStruct *) &call_back->strconv;
461 CARD16 connect_id = call_data->any.connect_id;
462
463 fm = FrameMgrInit(str_conversion_fr,
464 NULL,
465 _Xi18nNeedSwap(i18n_core, connect_id));
466 #if 0
467 /* set length of preedit string */
468 FrameMgrSetSize(fm, strconv->text->length);
469 #endif
470 total_size = FrameMgrGetTotalSize(fm);
471 reply = (unsigned char *) malloc(total_size);
472 if (!reply) {
473 _Xi18nSendMessage(ims, connect_id, XIM_ERROR, 0, 0, 0);
474 return False;
475 }
476 /*endif*/
477 memset(reply, 0, total_size);
478 FrameMgrSetBuffer(fm, reply);
479
480 FrameMgrPutToken(fm, connect_id);
481 FrameMgrPutToken(fm, call_back->icid);
482 FrameMgrPutToken(fm, strconv->position);
483 FrameMgrPutToken(fm, strconv->direction);
484 FrameMgrPutToken(fm, strconv->operation);
485 #if 0
486 FrameMgrPutToken(fm, strconv->text->string);
487 #endif
488 _Xi18nSendMessage(ims, connect_id,
489 XIM_STR_CONVERSION,
490 0,
491 reply,
492 total_size);
493 FrameMgrFree(fm);
494 XFree(reply);
495
496 /* XIM_STR_CONVERSION is a syncronous protocol,
497 so should wait here for XIM_STR_CONVERSION_REPLY. */
498 if (i18n_core->methods.wait(ims,
499 connect_id,
500 XIM_STR_CONVERSION_REPLY,
501 0) == False) {
502 return False;
503 }
504 /*endif*/
505 return True;
506 }
507
508 // kate: indent-mode cstyle; space-indent on; indent-width 0;
509