← Back to branch summary

~ubuntu-branches/ubuntu/raring/sunpinyin/raring

« back to all changes in this revision

Viewing changes to wrapper/xim/IMdkit/i18nClbk.c

  • Committer: Package Import Robot
  • Author(s): YunQiang Su
  • Date: 2012-03-30 15:31:55 UTC
  • mfrom: (1.3.2)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: package-import@ubuntu.com-20120330153155-r41lymnlhe2jpkqj
Tags: upstream-2.0.3+git20120222
Import upstream version 2.0.3+git20120222

Show diffs side-by-side

added added

removed removed

Lines of Context:
wrapper/xim/IMdkit/i18nClbk.c
 
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
 
 
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
 
 
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
 
 
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
 
 
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
 
 
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
 
 
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
 
 
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
 
 
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
 
 
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
 
 
477
    total_size = FrameMgrGetTotalSize (fm);
 
478
    reply = (unsigned char *) malloc (total_size);
 
479
    if (!reply)
 
480
    {
 
481
        _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
 
482
        return False;
 
483
    }
 
484
    /*endif*/
 
485
    memset (reply, 0, total_size);
 
486
    FrameMgrSetBuffer (fm, reply);
 
487
 
 
488
    FrameMgrPutToken (fm, connect_id);
 
489
    FrameMgrPutToken (fm, call_back->icid);
 
490
    FrameMgrPutToken (fm, strconv->position);
 
491
    FrameMgrPutToken (fm, strconv->direction);
 
492
    FrameMgrPutToken (fm, strconv->operation);
 
493
 
 
494
    _Xi18nSendMessage (ims, connect_id,
 
495
                       XIM_STR_CONVERSION,
 
496
                       0,
 
497
                       reply,
 
498
                       total_size);
 
499
    FrameMgrFree (fm);
 
500
    XFree (reply);
 
501
 
 
502
    /* XIM_STR_CONVERSION is a syncronous protocol,
 
503
       so should wait here for XIM_STR_CONVERSION_REPLY. */
 
504
    if (i18n_core->methods.wait (ims,
 
505
                                 connect_id,
 
506
                                 XIM_STR_CONVERSION_REPLY,
 
507
                                 0) == False)
 
508
    {
 
509
        return False;
 
510
    }
 
511
    /*endif*/
 
512
    return True;
 
513
}