← Back to branch summary

~ubuntu-branches/ubuntu/quantal/sunpinyin/quantal

« 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-04-11 03:06:40 UTC
  • mfrom: (1.1.4) (1.2.8 sid)
  • Revision ID: package-import@ubuntu.com-20120411030640-8mxepz5e6wffy87c
Tags: 2.0.3+git20120404-1
http://bugs.debian.org/667385
* Medium urgency for fixing RC bug.
* New upstream commit: fix FTBFS with gcc-4.7 (Closes: #667385).
* Add Multi-Arch: same to libsunpinyin3, -dev and -dbg.
* Add YunQiang Su to uploaders.

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
 
}