← Back to branch summary

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

« 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-03-30 15:31:55 UTC
  • mfrom: (1.1.3) (1.2.7 sid)
  • Revision ID: package-import@ubuntu.com-20120330153155-qgls77sogzgtg9zp
Tags: 2.0.3+git20120222-1
* Team upload: git snapshot 20120222.
   - fix breaks if LDFLAGS in environment contains
       multiple words (Closese #646001).
   - rm patches merged to upstream:
       append-os-environ-toenv.patch
       fix-ftbfs-on-sh.patch
       remove-10-candidate-words-limitation.patch
   - refresh disable-lm-dict-compile.patch.
* Bump stardard version to 3.9.3: no modify needed.
* add libsunpinyin3-dbg and python-sunpinyin packages.
* debian/compat to 9, multiarch it.
* rewrite debian/rules with dh 7 format.

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
}