← Back to branch summary

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

« back to all changes in this revision

Viewing changes to wrapper/xim/IMdkit/i18nIc.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/i18nIc.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
 
#define IC_SIZE 64
39
 
 
40
 
/* Set IC values */
41
 
static void SetCardAttribute (XICAttribute *value_ret,
42
 
                              char *p,
43
 
                              XICAttr *ic_attr,
44
 
                              int value_length,
45
 
                              int need_swap,
46
 
                              void **value_buf)
47
 
{
48
 
    FrameMgr fm;
49
 
 
50
 
    /*endif*/
51
 
    if (value_length == sizeof (CARD8))
52
 
    {
53
 
        memmove (*value_buf, p, value_length);
54
 
    }
55
 
    else if (value_length == sizeof (CARD16))
56
 
    {
57
 
        INT16 value;
58
 
        extern XimFrameRec short_fr[];
59
 
 
60
 
        fm = FrameMgrInit (short_fr, (char *) p, need_swap);
61
 
        /* get data */
62
 
        FrameMgrGetToken (fm, value);
63
 
        FrameMgrFree (fm);
64
 
        memmove (*value_buf, &value, value_length);
65
 
    }
66
 
    else if (value_length == sizeof(CARD32))
67
 
    {
68
 
        INT32 value;
69
 
        extern XimFrameRec long_fr[];
70
 
        
71
 
        fm = FrameMgrInit (long_fr, (char *) p, need_swap);
72
 
        /* get data */
73
 
        FrameMgrGetToken (fm, value);
74
 
        FrameMgrFree (fm);
75
 
        memmove (*value_buf, &value, value_length);
76
 
    }
77
 
    /*endif*/
78
 
    value_ret->attribute_id = ic_attr->attribute_id;
79
 
    value_ret->name = ic_attr->name;
80
 
    value_ret->name_length = ic_attr->length;
81
 
    value_ret->type = ic_attr->type;
82
 
    value_ret->value_length = value_length;
83
 
    value_ret->value = *value_buf;
84
 
 
85
 
    *value_buf += value_length;
86
 
}
87
 
 
88
 
static void SetFontAttribute (XICAttribute *value_ret,
89
 
                              char *p,
90
 
                              XICAttr *ic_attr,
91
 
                              int value_length,
92
 
                              int need_swap,
93
 
                              void **value_buf)
94
 
{
95
 
    char *base_name;
96
 
    CARD16 base_length;
97
 
    FrameMgr fm;
98
 
    extern XimFrameRec fontset_fr[];
99
 
 
100
 
    fm = FrameMgrInit (fontset_fr, (char *) p, need_swap);
101
 
    /* get data */
102
 
    FrameMgrGetToken (fm, base_length);
103
 
    FrameMgrSetSize (fm, base_length);
104
 
 
105
 
    /*endif*/
106
 
    FrameMgrGetToken (fm, base_name);
107
 
    FrameMgrFree(fm);
108
 
    strncpy ((char *) (*value_buf), base_name, base_length);
109
 
    ((char *) *value_buf)[base_length] = (char) 0;
110
 
 
111
 
    value_ret->attribute_id = ic_attr->attribute_id;
112
 
    value_ret->name = ic_attr->name;
113
 
    value_ret->name_length = ic_attr->length;
114
 
    value_ret->type = ic_attr->type;
115
 
    value_ret->value_length = value_length;
116
 
    value_ret->value = *value_buf;
117
 
 
118
 
    *value_buf += (base_length + 1);
119
 
}
120
 
 
121
 
static void SetPointAttribute (XICAttribute *value_ret,
122
 
                               char *p,
123
 
                               XICAttr *ic_attr,
124
 
                               int value_length,
125
 
                               int need_swap,
126
 
                               void **value_buf)
127
 
{
128
 
    XPoint *buf;
129
 
    FrameMgr fm;
130
 
    extern XimFrameRec xpoint_fr[];
131
 
 
132
 
    buf = (XPoint *) (*value_buf);
133
 
 
134
 
    fm = FrameMgrInit (xpoint_fr, (char *) p, need_swap);
135
 
    /* get data */
136
 
    FrameMgrGetToken (fm, buf->x);
137
 
    FrameMgrGetToken (fm, buf->y);
138
 
    FrameMgrFree (fm);
139
 
 
140
 
    value_ret->attribute_id = ic_attr->attribute_id;
141
 
    value_ret->name = ic_attr->name;
142
 
    value_ret->name_length = ic_attr->length;
143
 
    value_ret->type = ic_attr->type;
144
 
    value_ret->value_length = value_length;
145
 
    value_ret->value = (char *) buf;
146
 
 
147
 
    *value_buf += value_length;
148
 
}
149
 
 
150
 
static void SetRectAttribute (XICAttribute *value_ret,
151
 
                              char *p,
152
 
                              XICAttr *ic_attr,
153
 
                              int value_length,
154
 
                              int need_swap,
155
 
                              void **value_buf)
156
 
{
157
 
    XRectangle *buf;
158
 
    FrameMgr fm;
159
 
    extern XimFrameRec xrectangle_fr[];
160
 
 
161
 
    buf = (XRectangle *) (*value_buf);
162
 
 
163
 
    fm = FrameMgrInit (xrectangle_fr, (char *) p, need_swap);
164
 
    /* get data */
165
 
    FrameMgrGetToken (fm, buf->x);
166
 
    FrameMgrGetToken (fm, buf->y);
167
 
    FrameMgrGetToken (fm, buf->width);
168
 
    FrameMgrGetToken (fm, buf->height);
169
 
    FrameMgrFree (fm);
170
 
 
171
 
    value_ret->attribute_id = ic_attr->attribute_id;
172
 
    value_ret->name = ic_attr->name;
173
 
    value_ret->name_length = ic_attr->length;
174
 
    value_ret->type = ic_attr->type;
175
 
    value_ret->value_length = value_length;
176
 
    value_ret->value = (char *) buf;
177
 
 
178
 
    *value_buf += value_length;
179
 
}
180
 
 
181
 
#if 0
182
 
static void SetHotKeyAttribute (XICAttribute *value_ret,
183
 
                                char *p,
184
 
                                XICAttr *ic_attr,
185
 
                                int value_length,
186
 
                                int need_swap,
187
 
                                void **value_buf)
188
 
{
189
 
    INT32 list_number;
190
 
    XIMTriggerKey *hotkeys;
191
 
 
192
 
    memmove (&list_number, p, sizeof(INT32)); p += sizeof(INT32);
193
 
 
194
 
    hotkeys = (XIMTriggerKey *) (*value_buf);
195
 
 
196
 
    memmove (hotkeys, p, list_number*sizeof (XIMTriggerKey));
197
 
 
198
 
    value_ret->attribute_id = ic_attr->attribute_id;
199
 
    value_ret->name = ic_attr->name;
200
 
    value_ret->name_length = ic_attr->length;
201
 
    value_ret->type = ic_attr->type;
202
 
    value_ret->value_length = value_length;
203
 
    value_ret->value = (char *) hotkeys;
204
 
 
205
 
    *value_buf += value_length;
206
 
}
207
 
#endif
208
 
 
209
 
/* get IC values */
210
 
static void GetAttrHeader (unsigned char *rec,
211
 
                           XICAttribute *list,
212
 
                           int need_swap)
213
 
{
214
 
    FrameMgr fm;
215
 
    extern XimFrameRec attr_head_fr[];
216
 
 
217
 
    fm = FrameMgrInit (attr_head_fr, (char *) rec, need_swap);
218
 
    /* put data */
219
 
    FrameMgrPutToken (fm, list->attribute_id);
220
 
    FrameMgrPutToken (fm, list->value_length);
221
 
    FrameMgrFree (fm);
222
 
}
223
 
 
224
 
static void GetCardAttribute (char *rec, XICAttribute *list, int need_swap)
225
 
{
226
 
    FrameMgr fm;
227
 
    unsigned char *recp = (unsigned char *) rec;
228
 
 
229
 
    GetAttrHeader (recp, list, need_swap);
230
 
    recp += sizeof (CARD16)*2;
231
 
 
232
 
    if (list->value_length == sizeof (CARD8))
233
 
    {
234
 
        memmove (recp, list->value, list->value_length);
235
 
    }
236
 
    else if (list->value_length == sizeof (CARD16))
237
 
    {
238
 
        INT16 *value = (INT16 *) list->value;
239
 
        extern XimFrameRec short_fr[];
240
 
 
241
 
        fm = FrameMgrInit (short_fr, (char *) recp, need_swap);
242
 
        /* put data */
243
 
        FrameMgrPutToken (fm, *value);
244
 
        FrameMgrFree (fm);
245
 
    }
246
 
    else if (list->value_length == sizeof (CARD32))
247
 
    {
248
 
        INT32 *value = (INT32 *) list->value;
249
 
        extern XimFrameRec long_fr[];
250
 
 
251
 
        fm = FrameMgrInit (long_fr, (char *) recp, need_swap);
252
 
        /* put data */
253
 
        FrameMgrPutToken (fm, *value);
254
 
        FrameMgrFree (fm);
255
 
    }
256
 
    /*endif*/
257
 
}
258
 
 
259
 
static void GetFontAttribute(char *rec, XICAttribute *list, int need_swap)
260
 
{
261
 
    FrameMgr fm;
262
 
    extern XimFrameRec fontset_fr[];
263
 
    char *base_name = (char *) list->value;
264
 
    unsigned char *recp = (unsigned char *) rec;
265
 
 
266
 
    GetAttrHeader (recp, list, need_swap);
267
 
    recp += sizeof (CARD16)*2;
268
 
 
269
 
    fm = FrameMgrInit (fontset_fr, (char *)recp, need_swap);
270
 
    /* put data */
271
 
    FrameMgrSetSize (fm, list->value_length);
272
 
    FrameMgrPutToken (fm, list->value_length);
273
 
    FrameMgrPutToken (fm, base_name);
274
 
    FrameMgrFree (fm);
275
 
}
276
 
 
277
 
static void GetRectAttribute (char *rec, XICAttribute *list, int need_swap)
278
 
{
279
 
    FrameMgr fm;
280
 
    extern XimFrameRec xrectangle_fr[];
281
 
    XRectangle *rect = (XRectangle *) list->value;
282
 
    unsigned char *recp = (unsigned char *) rec;
283
 
 
284
 
    GetAttrHeader (recp, list, need_swap);
285
 
    recp += sizeof(CARD16)*2;
286
 
 
287
 
    if (rect) {
288
 
        fm = FrameMgrInit (xrectangle_fr, (char *) recp, need_swap);
289
 
        /* put data */
290
 
        FrameMgrPutToken (fm, rect->x);
291
 
        FrameMgrPutToken (fm, rect->y);
292
 
        FrameMgrPutToken (fm, rect->width);
293
 
        FrameMgrPutToken (fm, rect->height);
294
 
        FrameMgrFree (fm);
295
 
    }
296
 
}
297
 
 
298
 
static void GetPointAttribute (char *rec, XICAttribute *list, int need_swap)
299
 
{
300
 
    FrameMgr fm;
301
 
    extern XimFrameRec xpoint_fr[];
302
 
    XPoint *rect = (XPoint *) list->value;
303
 
    unsigned char *recp = (unsigned char *) rec;
304
 
 
305
 
    GetAttrHeader (recp, list, need_swap);
306
 
    recp += sizeof(CARD16)*2;
307
 
 
308
 
    fm = FrameMgrInit (xpoint_fr, (char *) recp, need_swap);
309
 
    /* put data */
310
 
    FrameMgrPutToken (fm, rect->x);
311
 
    FrameMgrPutToken (fm, rect->y);
312
 
    FrameMgrFree (fm);
313
 
}
314
 
 
315
 
static int ReadICValue (Xi18n i18n_core,
316
 
                        CARD16 icvalue_id,
317
 
                        int value_length,
318
 
                        void *p,
319
 
                        XICAttribute *value_ret,
320
 
                        CARD16 *number_ret,
321
 
                        int need_swap,
322
 
                        void **value_buf)
323
 
{
324
 
    XICAttr *ic_attr = i18n_core->address.xic_attr;
325
 
    int i;
326
 
 
327
 
    *number_ret = (CARD16) 0;
328
 
 
329
 
    for (i = 0;  i < i18n_core->address.ic_attr_num;  i++, ic_attr++)
330
 
    {
331
 
        if (ic_attr->attribute_id == icvalue_id)
332
 
            break;
333
 
        /*endif*/
334
 
    }
335
 
    /*endfor*/
336
 
    switch (ic_attr->type)
337
 
    {
338
 
    case XimType_NEST:
339
 
        {
340
 
            int total_length = 0;
341
 
            CARD16 attribute_ID;
342
 
            INT16 attribute_length;
343
 
            unsigned char *p1 = (unsigned char *) p;
344
 
            CARD16 ic_len = 0;
345
 
            CARD16 number;
346
 
            FrameMgr fm;
347
 
            extern XimFrameRec attr_head_fr[];
348
 
 
349
 
            while (total_length < value_length)
350
 
            {
351
 
                fm = FrameMgrInit (attr_head_fr, (char *) p1, need_swap);
352
 
                /* get data */
353
 
                FrameMgrGetToken (fm, attribute_ID);
354
 
                FrameMgrGetToken (fm, attribute_length);
355
 
                FrameMgrFree (fm);
356
 
                p1 += sizeof (CARD16)*2;
357
 
                ReadICValue (i18n_core,
358
 
                             attribute_ID,
359
 
                             attribute_length,
360
 
                             p1,
361
 
                             (value_ret + ic_len),
362
 
                             &number,
363
 
                             need_swap,
364
 
                             value_buf);
365
 
                ic_len++;
366
 
                *number_ret += number;
367
 
                p1 += attribute_length;
368
 
                p1 += IMPAD (attribute_length);
369
 
                total_length += (CARD16) sizeof(CARD16)*2
370
 
                                + (INT16) attribute_length
371
 
                                + IMPAD (attribute_length);
372
 
            }
373
 
            /*endwhile*/
374
 
            return ic_len;
375
 
        }
376
 
 
377
 
    case XimType_CARD8:
378
 
    case XimType_CARD16:
379
 
    case XimType_CARD32:
380
 
    case XimType_Window:
381
 
        SetCardAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
382
 
        *number_ret = (CARD16) 1;
383
 
        return *number_ret;
384
 
 
385
 
    case XimType_XFontSet:
386
 
        SetFontAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
387
 
        *number_ret = (CARD16) 1;
388
 
        return *number_ret;
389
 
 
390
 
    case XimType_XRectangle:
391
 
        SetRectAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
392
 
        *number_ret = (CARD16) 1;
393
 
        return *number_ret;
394
 
 
395
 
    case XimType_XPoint:
396
 
        SetPointAttribute(value_ret, p, ic_attr, value_length, need_swap, value_buf);
397
 
        *number_ret = (CARD16) 1;
398
 
        return *number_ret;
399
 
 
400
 
#if 0
401
 
    case XimType_XIMHotKeyTriggers:
402
 
        SetHotKeyAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
403
 
        *number_ret = (CARD16) 1;
404
 
        return *number_ret;
405
 
#endif
406
 
    }
407
 
    /*endswitch*/
408
 
    return 0;
409
 
}
410
 
 
411
 
static XICAttribute *CreateNestedList (CARD16 attr_id,
412
 
                                       XICAttribute *list,
413
 
                                       int number,
414
 
                                       int need_swap)
415
 
{
416
 
    XICAttribute *nest_list = NULL;
417
 
    register int i;
418
 
    char *values = NULL;
419
 
    char *valuesp;
420
 
    int value_length = 0;
421
 
 
422
 
    if (number == 0)
423
 
        return NULL;
424
 
    /*endif*/
425
 
    for (i = 0;  i < number;  i++)
426
 
    {
427
 
        value_length += sizeof (CARD16)*2;
428
 
        value_length += list[i].value_length;
429
 
        value_length += IMPAD (list[i].value_length);
430
 
    }
431
 
    /*endfor*/
432
 
    if ((values = (char *) malloc (value_length)) == NULL)
433
 
        return NULL;
434
 
    /*endif*/
435
 
    memset (values, 0, value_length);
436
 
 
437
 
    valuesp = values;
438
 
    for (i = 0;  i < number;  i++)
439
 
    {
440
 
        switch (list[i].type)
441
 
        {
442
 
        case XimType_CARD8:
443
 
        case XimType_CARD16:
444
 
        case XimType_CARD32:
445
 
        case XimType_Window:
446
 
            GetCardAttribute (valuesp, &list[i], need_swap);
447
 
            break;
448
 
 
449
 
        case XimType_XFontSet:
450
 
            GetFontAttribute (valuesp, &list[i], need_swap);
451
 
            break;
452
 
 
453
 
        case XimType_XRectangle:
454
 
            GetRectAttribute (valuesp, &list[i], need_swap);
455
 
            break;
456
 
 
457
 
        case XimType_XPoint:
458
 
            GetPointAttribute (valuesp, &list[i], need_swap);
459
 
            break;
460
 
 
461
 
#if 0
462
 
        case XimType_XIMHotKeyTriggers:
463
 
            GetHotKeyAttribute (valuesp, &list[i], need_swap);
464
 
            break;
465
 
#endif
466
 
        }
467
 
        /*endswitch*/
468
 
        valuesp += sizeof (CARD16)*2;
469
 
        valuesp += list[i].value_length;
470
 
        valuesp += IMPAD(list[i].value_length);
471
 
    }
472
 
    /*endfor*/
473
 
    
474
 
    nest_list = (XICAttribute *) malloc (sizeof (XICAttribute));
475
 
    if (nest_list == NULL)
476
 
        return NULL;
477
 
    /*endif*/
478
 
    memset (nest_list, 0, sizeof (XICAttribute));
479
 
    nest_list->value = (void *) malloc (value_length);
480
 
    if (nest_list->value == NULL)
481
 
        return NULL;
482
 
    /*endif*/
483
 
    memset (nest_list->value, 0, sizeof (value_length));
484
 
 
485
 
    nest_list->attribute_id = attr_id;
486
 
    nest_list->value_length = value_length;
487
 
    memmove (nest_list->value, values, value_length);
488
 
 
489
 
    XFree (values);
490
 
    return nest_list;
491
 
}
492
 
 
493
 
static Bool IsNestedList (Xi18n i18n_core, CARD16 icvalue_id)
494
 
{
495
 
    XICAttr *ic_attr = i18n_core->address.xic_attr;
496
 
    int i;
497
 
 
498
 
    for (i = 0;  i < i18n_core->address.ic_attr_num;  i++, ic_attr++)
499
 
    {
500
 
        if (ic_attr->attribute_id == icvalue_id)
501
 
        {
502
 
            if (ic_attr->type == XimType_NEST)
503
 
                return True;
504
 
            /*endif*/
505
 
            return False;
506
 
        }
507
 
        /*endif*/
508
 
    }
509
 
    /*endfor*/
510
 
    return False;
511
 
}
512
 
 
513
 
static Bool IsSeparator (Xi18n i18n_core, CARD16 icvalue_id)
514
 
{
515
 
    return (i18n_core->address.separatorAttr_id == icvalue_id);
516
 
}
517
 
 
518
 
static int GetICValue (Xi18n i18n_core,
519
 
                       XICAttribute *attr_ret,
520
 
                       CARD16 *id_list,
521
 
                       int list_num)
522
 
{
523
 
    XICAttr *xic_attr = i18n_core->address.xic_attr;
524
 
    register int i;
525
 
    register int j;
526
 
    register int n;
527
 
 
528
 
    i =
529
 
    n = 0;
530
 
    if (IsNestedList (i18n_core, id_list[i]))
531
 
    {
532
 
        i++;
533
 
        while (i < list_num  &&  !IsSeparator (i18n_core, id_list[i]))
534
 
        {
535
 
            for (j = 0;  j < i18n_core->address.ic_attr_num;  j++)
536
 
            {
537
 
                if (xic_attr[j].attribute_id == id_list[i])
538
 
                {
539
 
                    attr_ret[n].attribute_id = xic_attr[j].attribute_id;
540
 
                    attr_ret[n].name_length = xic_attr[j].length;
541
 
                    attr_ret[n].name = malloc (xic_attr[j].length + 1);
542
 
                    strcpy(attr_ret[n].name, xic_attr[j].name);
543
 
                    attr_ret[n].type = xic_attr[j].type;
544
 
                    n++;
545
 
                    i++;
546
 
                    break;
547
 
                }
548
 
                /*endif*/
549
 
            }
550
 
            /*endfor*/
551
 
        }
552
 
        /*endwhile*/
553
 
    }
554
 
    else
555
 
    {
556
 
        for (j = 0;  j < i18n_core->address.ic_attr_num;  j++)
557
 
        {
558
 
            if (xic_attr[j].attribute_id == id_list[i])
559
 
            {
560
 
                attr_ret[n].attribute_id = xic_attr[j].attribute_id;
561
 
                attr_ret[n].name_length = xic_attr[j].length;
562
 
                attr_ret[n].name = malloc (xic_attr[j].length + 1);
563
 
                strcpy(attr_ret[n].name, xic_attr[j].name);
564
 
                attr_ret[n].type = xic_attr[j].type;
565
 
                n++;
566
 
                break;
567
 
            }
568
 
            /*endif*/
569
 
        }
570
 
        /*endfor*/
571
 
    }
572
 
    /*endif*/
573
 
    return n;
574
 
}
575
 
 
576
 
static void SwapAttributes (XICAttribute *list,
577
 
                           int number){
578
 
    FrameMgr fm;
579
 
    CARD16 c16;
580
 
    extern XimFrameRec short_fr[];
581
 
    CARD32 c32;
582
 
    extern XimFrameRec long_fr[];
583
 
    XPoint xpoint;
584
 
    extern XimFrameRec xpoint_fr[];
585
 
    XRectangle xrect;
586
 
    extern XimFrameRec xrectangle_fr[];
587
 
    int i;
588
 
 
589
 
    for (i = 0; i < number; ++i, ++list) {
590
 
        if (list->value == NULL)
591
 
            continue;
592
 
        switch (list->type) {
593
 
        case XimType_CARD16:
594
 
            fm = FrameMgrInit (short_fr, (char *)list->value, 1);
595
 
            FrameMgrGetToken (fm, c16);
596
 
            memmove(list->value, &c16, sizeof(CARD16));
597
 
            FrameMgrFree (fm);
598
 
            break;
599
 
        case XimType_CARD32:
600
 
        case XimType_Window:
601
 
            fm = FrameMgrInit (long_fr, (char *)list->value, 1);
602
 
            FrameMgrGetToken (fm, c32);
603
 
            memmove(list->value, &c32, sizeof(CARD32));
604
 
            FrameMgrFree (fm);
605
 
            break;
606
 
        case XimType_XRectangle:
607
 
            fm = FrameMgrInit (xrectangle_fr, (char *)list->value, 1);
608
 
            FrameMgrGetToken (fm, xrect);
609
 
            memmove(list->value, &xrect, sizeof(XRectangle));
610
 
            FrameMgrFree (fm);
611
 
            break;
612
 
        case XimType_XPoint:
613
 
            fm = FrameMgrInit (xpoint_fr, (char *)list->value, 1);
614
 
            FrameMgrGetToken (fm, xpoint);
615
 
            memmove(list->value, &xpoint, sizeof(XPoint));
616
 
            FrameMgrFree (fm);
617
 
            break;
618
 
        default:
619
 
            break;
620
 
        }
621
 
    }
622
 
}
623
 
 
624
 
/* called from CreateICMessageProc and SetICValueMessageProc */
625
 
void _Xi18nChangeIC (XIMS ims,
626
 
                     IMProtocol *call_data,
627
 
                     unsigned char *p,
628
 
                     int create_flag)
629
 
{
630
 
    Xi18n i18n_core = ims->protocol;
631
 
    FrameMgr fm;
632
 
    FmStatus status;
633
 
    CARD16 byte_length;
634
 
    register int total_size;
635
 
    unsigned char *reply = NULL;
636
 
    register int i;
637
 
    register int attrib_num;
638
 
    XICAttribute *attrib_list;
639
 
    XICAttribute pre_attr[IC_SIZE];
640
 
    XICAttribute sts_attr[IC_SIZE];
641
 
    XICAttribute ic_attr[IC_SIZE];
642
 
    CARD16 preedit_ic_num = 0;
643
 
    CARD16 status_ic_num = 0;
644
 
    CARD16 ic_num = 0;
645
 
    CARD16 connect_id = call_data->any.connect_id;
646
 
    IMChangeICStruct *changeic = (IMChangeICStruct *) &call_data->changeic;
647
 
    extern XimFrameRec create_ic_fr[];
648
 
    extern XimFrameRec create_ic_reply_fr[];
649
 
    extern XimFrameRec set_ic_values_fr[];
650
 
    extern XimFrameRec set_ic_values_reply_fr[];
651
 
    CARD16 input_method_ID;
652
 
 
653
 
    void *value_buf = NULL;
654
 
    void *value_buf_ptr;
655
 
 
656
 
    register int total_value_length = 0;
657
 
 
658
 
    memset (pre_attr, 0, sizeof (XICAttribute)*IC_SIZE);
659
 
    memset (sts_attr, 0, sizeof (XICAttribute)*IC_SIZE);
660
 
    memset (ic_attr, 0, sizeof (XICAttribute)*IC_SIZE);
661
 
 
662
 
    if (create_flag == True)
663
 
    {
664
 
        fm = FrameMgrInit (create_ic_fr,
665
 
                           (char *) p,
666
 
                           _Xi18nNeedSwap (i18n_core, connect_id));
667
 
        /* get data */
668
 
        FrameMgrGetToken (fm, input_method_ID);
669
 
        FrameMgrGetToken (fm, byte_length);
670
 
    }
671
 
    else
672
 
    {
673
 
        fm = FrameMgrInit (set_ic_values_fr,
674
 
                           (char *) p,
675
 
                           _Xi18nNeedSwap (i18n_core, connect_id));
676
 
        /* get data */
677
 
        FrameMgrGetToken (fm, input_method_ID);
678
 
        FrameMgrGetToken (fm, changeic->icid);
679
 
        FrameMgrGetToken (fm, byte_length);
680
 
    }
681
 
    /*endif*/
682
 
    attrib_list = (XICAttribute *) malloc (sizeof (XICAttribute)*IC_SIZE);
683
 
    if (!attrib_list)
684
 
    {
685
 
        _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
686
 
        return;
687
 
    }
688
 
    /*endif*/
689
 
    memset (attrib_list, 0, sizeof(XICAttribute)*IC_SIZE);
690
 
 
691
 
    attrib_num = 0;
692
 
    while (FrameMgrIsIterLoopEnd (fm, &status) == False)
693
 
    {
694
 
        void *value;
695
 
        int value_length;
696
 
        
697
 
        FrameMgrGetToken (fm, attrib_list[attrib_num].attribute_id);
698
 
        FrameMgrGetToken (fm, value_length);
699
 
        FrameMgrSetSize (fm, value_length);
700
 
        attrib_list[attrib_num].value_length = value_length;
701
 
        FrameMgrGetToken (fm, value);
702
 
        attrib_list[attrib_num].value = (void *) malloc (value_length + 1);
703
 
        memmove (attrib_list[attrib_num].value, value, value_length);
704
 
        ((char *)attrib_list[attrib_num].value)[value_length] = '\0';
705
 
        attrib_num++;
706
 
        total_value_length += (value_length + 1);
707
 
    }
708
 
    /*endwhile*/
709
 
 
710
 
    value_buf = (void *) malloc (total_value_length);
711
 
    value_buf_ptr = value_buf;
712
 
 
713
 
    if (!value_buf)
714
 
    {
715
 
        _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
716
 
        for (i = 0;  i < attrib_num;  i++)
717
 
            XFree (attrib_list[i].value);
718
 
        /*endfor*/
719
 
        XFree (attrib_list);
720
 
        return;
721
 
    }
722
 
    /*endif*/
723
 
 
724
 
    for (i = 0;  i < attrib_num;  i++)
725
 
    {
726
 
        CARD16 number;
727
 
        
728
 
        if (IsNestedList (i18n_core, attrib_list[i].attribute_id))
729
 
        {
730
 
            if (attrib_list[i].attribute_id
731
 
                == i18n_core->address.preeditAttr_id)
732
 
            {
733
 
                ReadICValue (i18n_core,
734
 
                             attrib_list[i].attribute_id,
735
 
                             attrib_list[i].value_length,
736
 
                             attrib_list[i].value,
737
 
                             &pre_attr[preedit_ic_num],
738
 
                             &number,
739
 
                             _Xi18nNeedSwap(i18n_core, connect_id),
740
 
                             &value_buf_ptr);
741
 
                preedit_ic_num += number;
742
 
            }
743
 
            else if (attrib_list[i].attribute_id == i18n_core->address.statusAttr_id)
744
 
            {
745
 
                ReadICValue (i18n_core,
746
 
                             attrib_list[i].attribute_id,
747
 
                             attrib_list[i].value_length,
748
 
                             attrib_list[i].value,
749
 
                             &sts_attr[status_ic_num],
750
 
                             &number,
751
 
                             _Xi18nNeedSwap (i18n_core, connect_id),
752
 
                             &value_buf_ptr);
753
 
                status_ic_num += number;
754
 
            }
755
 
            else
756
 
            {
757
 
                /* another nested list.. possible? */
758
 
            }
759
 
            /*endif*/
760
 
        }
761
 
        else
762
 
        {
763
 
            ReadICValue (i18n_core,
764
 
                         attrib_list[i].attribute_id,
765
 
                         attrib_list[i].value_length,
766
 
                         attrib_list[i].value,
767
 
                         &ic_attr[ic_num],
768
 
                         &number,
769
 
                         _Xi18nNeedSwap (i18n_core, connect_id),
770
 
                         &value_buf_ptr);
771
 
            ic_num += number;
772
 
        }
773
 
        /*endif*/
774
 
    }
775
 
    /*endfor*/
776
 
    for (i = 0;  i < attrib_num;  i++)
777
 
        XFree (attrib_list[i].value);
778
 
    /*endfor*/
779
 
    XFree (attrib_list);
780
 
 
781
 
    FrameMgrFree (fm);
782
 
 
783
 
    changeic->preedit_attr_num = preedit_ic_num;
784
 
    changeic->status_attr_num = status_ic_num;
785
 
    changeic->ic_attr_num = ic_num;
786
 
    changeic->preedit_attr = pre_attr;
787
 
    changeic->status_attr = sts_attr;
788
 
    changeic->ic_attr = ic_attr;
789
 
 
790
 
    if (i18n_core->address.improto)
791
 
    {
792
 
        if (!(i18n_core->address.improto(ims, call_data))) {
793
 
            XFree (value_buf);
794
 
            return;
795
 
        }
796
 
        /*endif*/
797
 
    }
798
 
 
799
 
    XFree (value_buf);
800
 
 
801
 
    /*endif*/
802
 
    if (create_flag == True)
803
 
    {
804
 
        fm = FrameMgrInit (create_ic_reply_fr,
805
 
                           NULL,
806
 
                           _Xi18nNeedSwap (i18n_core, connect_id));
807
 
    }
808
 
    else
809
 
    {
810
 
        fm = FrameMgrInit (set_ic_values_reply_fr,
811
 
                           NULL,
812
 
                           _Xi18nNeedSwap (i18n_core, connect_id));
813
 
    }
814
 
    /*endif*/
815
 
    total_size = FrameMgrGetTotalSize (fm);
816
 
    reply = (unsigned char *) malloc (total_size);
817
 
    
818
 
    if (!reply)
819
 
    {
820
 
        _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
821
 
        return;
822
 
    }
823
 
    /*endif*/
824
 
    memset (reply, 0, total_size);
825
 
    FrameMgrSetBuffer (fm, reply);
826
 
 
827
 
    FrameMgrPutToken (fm, input_method_ID);
828
 
    FrameMgrPutToken (fm, changeic->icid);
829
 
 
830
 
    if (create_flag == True)
831
 
    {
832
 
        _Xi18nSendMessage (ims,
833
 
                           connect_id,
834
 
                           XIM_CREATE_IC_REPLY,
835
 
                           0,
836
 
                           reply,
837
 
                           total_size);
838
 
    }
839
 
    else
840
 
    {
841
 
        _Xi18nSendMessage (ims,
842
 
                           connect_id,
843
 
                           XIM_SET_IC_VALUES_REPLY,
844
 
                           0,
845
 
                           reply,
846
 
                           total_size);
847
 
    }
848
 
    /*endif*/
849
 
    if (create_flag == True)
850
 
    {
851
 
        int on_key_num = i18n_core->address.on_keys.count_keys;
852
 
        int off_key_num = i18n_core->address.off_keys.count_keys;
853
 
 
854
 
        if (on_key_num == 0  &&  off_key_num == 0)
855
 
        {
856
 
            long mask;
857
 
 
858
 
            if (i18n_core->address.imvalue_mask & I18N_FILTERMASK)
859
 
                mask = i18n_core->address.filterevent_mask;
860
 
            else
861
 
                mask = DEFAULT_FILTER_MASK;
862
 
            /*endif*/
863
 
            /* static event flow is default */
864
 
            _Xi18nSetEventMask (ims,
865
 
                                connect_id,
866
 
                                input_method_ID,
867
 
                                changeic->icid,
868
 
                                mask,
869
 
                                ~mask);
870
 
        }
871
 
        /*endif*/
872
 
    }
873
 
    /*endif*/
874
 
    FrameMgrFree (fm);
875
 
    XFree(reply);
876
 
}
877
 
 
878
 
/* called from GetICValueMessageProc */
879
 
void _Xi18nGetIC (XIMS ims, IMProtocol *call_data, unsigned char *p)
880
 
{
881
 
    Xi18n i18n_core = ims->protocol;
882
 
    FrameMgr fm;
883
 
    FmStatus status;
884
 
    extern XimFrameRec get_ic_values_fr[];
885
 
    extern XimFrameRec get_ic_values_reply_fr[];
886
 
    CARD16 byte_length;
887
 
    register int total_size;
888
 
    unsigned char *reply = NULL;
889
 
    XICAttribute *preedit_ret = NULL;
890
 
    XICAttribute *status_ret = NULL;
891
 
    register int i;
892
 
    register int number;
893
 
    int iter_count;
894
 
    CARD16 *attrID_list;
895
 
    XICAttribute pre_attr[IC_SIZE];
896
 
    XICAttribute sts_attr[IC_SIZE];
897
 
    XICAttribute ic_attr[IC_SIZE];
898
 
    CARD16 pre_count = 0;
899
 
    CARD16 sts_count = 0;
900
 
    CARD16 ic_count = 0;
901
 
    IMChangeICStruct *getic = (IMChangeICStruct *) &call_data->changeic;
902
 
    CARD16 connect_id = call_data->any.connect_id;
903
 
    CARD16 input_method_ID;
904
 
 
905
 
    memset (pre_attr, 0, sizeof (XICAttribute)*IC_SIZE);
906
 
    memset (sts_attr, 0, sizeof (XICAttribute)*IC_SIZE);
907
 
    memset (ic_attr, 0, sizeof (XICAttribute)*IC_SIZE);
908
 
 
909
 
    fm = FrameMgrInit (get_ic_values_fr,
910
 
                       (char *) p,
911
 
                       _Xi18nNeedSwap (i18n_core, connect_id));
912
 
 
913
 
    /* get data */
914
 
    FrameMgrGetToken (fm, input_method_ID);
915
 
    FrameMgrGetToken (fm, getic->icid);
916
 
    FrameMgrGetToken (fm, byte_length);
917
 
 
918
 
    attrID_list = (CARD16 *) malloc (sizeof (CARD16)*IC_SIZE);  /* bogus */
919
 
    memset (attrID_list, 0, sizeof (CARD16)*IC_SIZE);
920
 
 
921
 
    number = 0;
922
 
    while (FrameMgrIsIterLoopEnd (fm, &status) == False)
923
 
        FrameMgrGetToken (fm, attrID_list[number++]);
924
 
    /*endwhile*/
925
 
    FrameMgrFree (fm);
926
 
 
927
 
    i = 0;
928
 
    while (i < number)
929
 
    {
930
 
        int read_number;
931
 
        
932
 
        if (IsNestedList (i18n_core, attrID_list[i]))
933
 
        {
934
 
            if (attrID_list[i] == i18n_core->address.preeditAttr_id)
935
 
            {
936
 
                read_number = GetICValue (i18n_core,
937
 
                                          &pre_attr[pre_count],
938
 
                                          &attrID_list[i],
939
 
                                          number);
940
 
                i += read_number + 1;
941
 
                pre_count += read_number;
942
 
            }
943
 
            else if (attrID_list[i] == i18n_core->address.statusAttr_id)
944
 
            {
945
 
                read_number = GetICValue (i18n_core,
946
 
                                          &sts_attr[sts_count],
947
 
                                          &attrID_list[i],
948
 
                                          number);
949
 
                i += read_number + 1;
950
 
                sts_count += read_number;
951
 
            }
952
 
            else
953
 
            {
954
 
                /* another nested list.. possible? */
955
 
            }
956
 
            /*endif*/
957
 
        }
958
 
        else
959
 
        {
960
 
            read_number = GetICValue (i18n_core,
961
 
                                      &ic_attr[ic_count],
962
 
                                      &attrID_list[i],
963
 
                                      number);
964
 
            i += read_number;
965
 
            ic_count += read_number;
966
 
        }
967
 
        /*endif*/
968
 
    }
969
 
    /*endwhile*/
970
 
    getic->preedit_attr_num = pre_count;
971
 
    getic->status_attr_num = sts_count;
972
 
    getic->ic_attr_num = ic_count;
973
 
    getic->preedit_attr = pre_attr;
974
 
    getic->status_attr = sts_attr;
975
 
    getic->ic_attr = ic_attr;
976
 
    if (i18n_core->address.improto)
977
 
    {
978
 
        if (!(i18n_core->address.improto (ims, call_data)))
979
 
            return;
980
 
        /*endif*/
981
 
        if (_Xi18nNeedSwap (i18n_core, connect_id))
982
 
          SwapAttributes(getic->ic_attr, getic->ic_attr_num);
983
 
    }
984
 
    /*endif*/
985
 
    iter_count = getic->ic_attr_num;
986
 
 
987
 
    preedit_ret = CreateNestedList (i18n_core->address.preeditAttr_id,
988
 
                                    getic->preedit_attr,
989
 
                                    getic->preedit_attr_num,
990
 
                                    _Xi18nNeedSwap (i18n_core, connect_id));
991
 
    if (preedit_ret)
992
 
        iter_count++;
993
 
    /*endif*/
994
 
    status_ret = CreateNestedList (i18n_core->address.statusAttr_id,
995
 
                                   getic->status_attr,
996
 
                                   getic->status_attr_num,
997
 
                                   _Xi18nNeedSwap (i18n_core, connect_id));
998
 
    if (status_ret)
999
 
        iter_count++;
1000
 
    /*endif*/
1001
 
 
1002
 
    fm = FrameMgrInit (get_ic_values_reply_fr,
1003
 
                       NULL,
1004
 
                       _Xi18nNeedSwap (i18n_core, connect_id));
1005
 
 
1006
 
    /* set iteration count for list of ic_attribute */
1007
 
    FrameMgrSetIterCount (fm, iter_count);
1008
 
 
1009
 
    /* set length of BARRAY item in xicattribute_fr */
1010
 
    for (i = 0;  i < (int) getic->ic_attr_num;  i++)
1011
 
        FrameMgrSetSize (fm, ic_attr[i].value_length);
1012
 
    /*endfor*/
1013
 
    
1014
 
    if (preedit_ret)
1015
 
        FrameMgrSetSize (fm, preedit_ret->value_length);
1016
 
    /*endif*/
1017
 
    if (status_ret)
1018
 
        FrameMgrSetSize (fm, status_ret->value_length);
1019
 
    /*endif*/
1020
 
    total_size = FrameMgrGetTotalSize (fm);
1021
 
    reply = (unsigned char *) malloc (total_size);
1022
 
    if (reply == NULL)
1023
 
    {
1024
 
        _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
1025
 
        return;
1026
 
    }
1027
 
    /*endif*/
1028
 
    memset (reply, 0, total_size);
1029
 
    FrameMgrSetBuffer (fm, reply);
1030
 
 
1031
 
    FrameMgrPutToken (fm, input_method_ID);
1032
 
    FrameMgrPutToken (fm, getic->icid);
1033
 
 
1034
 
    for (i = 0;  i < (int) getic->ic_attr_num;  i++)
1035
 
    {
1036
 
        FrameMgrPutToken (fm, ic_attr[i].attribute_id);
1037
 
        FrameMgrPutToken (fm, ic_attr[i].value_length);
1038
 
        FrameMgrPutToken (fm, ic_attr[i].value);
1039
 
    }
1040
 
    /*endfor*/
1041
 
    if (preedit_ret)
1042
 
    {
1043
 
        FrameMgrPutToken (fm, preedit_ret->attribute_id);
1044
 
        FrameMgrPutToken (fm, preedit_ret->value_length);
1045
 
        FrameMgrPutToken (fm, preedit_ret->value);
1046
 
    }
1047
 
    /*endif*/
1048
 
    if (status_ret)
1049
 
    {
1050
 
        FrameMgrPutToken (fm, status_ret->attribute_id);
1051
 
        FrameMgrPutToken (fm, status_ret->value_length);
1052
 
        FrameMgrPutToken (fm, status_ret->value);
1053
 
    }
1054
 
    /*endif*/
1055
 
    _Xi18nSendMessage (ims,
1056
 
                       connect_id,
1057
 
                       XIM_GET_IC_VALUES_REPLY,
1058
 
                       0,
1059
 
                       reply,
1060
 
                       total_size);
1061
 
    XFree (reply);
1062
 
    XFree (attrID_list);
1063
 
 
1064
 
    for (i = 0;  i < (int) getic->ic_attr_num;  i++)
1065
 
    {
1066
 
        if (getic->ic_attr[i].name)
1067
 
            XFree (getic->ic_attr[i].name);
1068
 
        /*endif*/
1069
 
        if (getic->ic_attr[i].value)
1070
 
            XFree (getic->ic_attr[i].value);
1071
 
        /*endif*/
1072
 
    }
1073
 
    /*endfor*/
1074
 
    for (i = 0;  i < (int) getic->preedit_attr_num;  i++)
1075
 
    {
1076
 
        if (getic->preedit_attr[i].name)
1077
 
            XFree (getic->preedit_attr[i].name);
1078
 
        /*endif*/
1079
 
        if (getic->preedit_attr[i].value)
1080
 
            XFree (getic->preedit_attr[i].value);
1081
 
        /*endif*/
1082
 
    }
1083
 
    /*endfor*/
1084
 
    for (i = 0;  i < (int) getic->status_attr_num;  i++)
1085
 
    {
1086
 
        if (getic->status_attr[i].name)
1087
 
            XFree (getic->status_attr[i].name);
1088
 
        /*endif*/
1089
 
        if (getic->status_attr[i].value)
1090
 
            XFree (getic->status_attr[i].value);
1091
 
        /*endif*/
1092
 
    }
1093
 
    /*endfor*/
1094
 
    
1095
 
    if (preedit_ret)
1096
 
    {
1097
 
        XFree (preedit_ret->value);
1098
 
        XFree (preedit_ret);
1099
 
    }
1100
 
    /*endif*/
1101
 
    if (status_ret)
1102
 
    {
1103
 
        XFree (status_ret->value);
1104
 
        XFree (status_ret);
1105
 
    }
1106
 
    /*endif*/
1107
 
    FrameMgrFree (fm);
1108
 
}