1 /******************************************************************
3 Copyright 1994, 1995 by Sun Microsystems, Inc.
4 Copyright 1993, 1994 by Hewlett-Packard Company
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.
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.
26 Author: Hidetoshi Tajima(tajima@Eng.Sun.COM) Sun Microsystems, Inc.
28 This version tidied and debugged by Steve Underwood May 1999
30 ******************************************************************/
41 static void SetCardAttribute (XICAttribute *value_ret,
51 if (value_length == sizeof (CARD8))
53 memmove (*value_buf, p, value_length);
55 else if (value_length == sizeof (CARD16))
58 extern XimFrameRec short_fr[];
60 fm = FrameMgrInit (short_fr, (char *) p, need_swap);
62 FrameMgrGetToken (fm, value);
64 memmove (*value_buf, &value, value_length);
66 else if (value_length == sizeof(CARD32))
69 extern XimFrameRec long_fr[];
71 fm = FrameMgrInit (long_fr, (char *) p, need_swap);
73 FrameMgrGetToken (fm, value);
75 memmove (*value_buf, &value, value_length);
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;
85 *value_buf += value_length;
88 static void SetFontAttribute (XICAttribute *value_ret,
98 extern XimFrameRec fontset_fr[];
100 fm = FrameMgrInit (fontset_fr, (char *) p, need_swap);
102 FrameMgrGetToken (fm, base_length);
103 FrameMgrSetSize (fm, base_length);
106 FrameMgrGetToken (fm, base_name);
108 strncpy ((char *) (*value_buf), base_name, base_length);
109 ((char *) *value_buf)[base_length] = (char) 0;
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;
118 *value_buf += (base_length + 1);
121 static void SetPointAttribute (XICAttribute *value_ret,
130 extern XimFrameRec xpoint_fr[];
132 buf = (XPoint *) (*value_buf);
134 fm = FrameMgrInit (xpoint_fr, (char *) p, need_swap);
136 FrameMgrGetToken (fm, buf->x);
137 FrameMgrGetToken (fm, buf->y);
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;
147 *value_buf += value_length;
150 static void SetRectAttribute (XICAttribute *value_ret,
159 extern XimFrameRec xrectangle_fr[];
161 buf = (XRectangle *) (*value_buf);
163 fm = FrameMgrInit (xrectangle_fr, (char *) p, need_swap);
165 FrameMgrGetToken (fm, buf->x);
166 FrameMgrGetToken (fm, buf->y);
167 FrameMgrGetToken (fm, buf->width);
168 FrameMgrGetToken (fm, buf->height);
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;
178 *value_buf += value_length;
182 static void SetHotKeyAttribute (XICAttribute *value_ret,
190 XIMTriggerKey *hotkeys;
192 memmove (&list_number, p, sizeof(INT32)); p += sizeof(INT32);
194 hotkeys = (XIMTriggerKey *) (*value_buf);
196 memmove (hotkeys, p, list_number*sizeof (XIMTriggerKey));
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;
205 *value_buf += value_length;
210 static void GetAttrHeader (unsigned char *rec,
215 extern XimFrameRec attr_head_fr[];
217 fm = FrameMgrInit (attr_head_fr, (char *) rec, need_swap);
219 FrameMgrPutToken (fm, list->attribute_id);
220 FrameMgrPutToken (fm, list->value_length);
224 static void GetCardAttribute (char *rec, XICAttribute *list, int need_swap)
227 unsigned char *recp = (unsigned char *) rec;
229 GetAttrHeader (recp, list, need_swap);
230 recp += sizeof (CARD16)*2;
232 if (list->value_length == sizeof (CARD8))
234 memmove (recp, list->value, list->value_length);
236 else if (list->value_length == sizeof (CARD16))
238 INT16 *value = (INT16 *) list->value;
239 extern XimFrameRec short_fr[];
241 fm = FrameMgrInit (short_fr, (char *) recp, need_swap);
243 FrameMgrPutToken (fm, *value);
246 else if (list->value_length == sizeof (CARD32))
248 INT32 *value = (INT32 *) list->value;
249 extern XimFrameRec long_fr[];
251 fm = FrameMgrInit (long_fr, (char *) recp, need_swap);
253 FrameMgrPutToken (fm, *value);
259 static void GetFontAttribute(char *rec, XICAttribute *list, int need_swap)
262 extern XimFrameRec fontset_fr[];
263 char *base_name = (char *) list->value;
264 unsigned char *recp = (unsigned char *) rec;
266 GetAttrHeader (recp, list, need_swap);
267 recp += sizeof (CARD16)*2;
269 fm = FrameMgrInit (fontset_fr, (char *)recp, need_swap);
271 FrameMgrSetSize (fm, list->value_length);
272 FrameMgrPutToken (fm, list->value_length);
273 FrameMgrPutToken (fm, base_name);
277 static void GetRectAttribute (char *rec, XICAttribute *list, int need_swap)
280 extern XimFrameRec xrectangle_fr[];
281 XRectangle *rect = (XRectangle *) list->value;
282 unsigned char *recp = (unsigned char *) rec;
284 GetAttrHeader (recp, list, need_swap);
285 recp += sizeof(CARD16)*2;
288 fm = FrameMgrInit (xrectangle_fr, (char *) recp, need_swap);
290 FrameMgrPutToken (fm, rect->x);
291 FrameMgrPutToken (fm, rect->y);
292 FrameMgrPutToken (fm, rect->width);
293 FrameMgrPutToken (fm, rect->height);
298 static void GetPointAttribute (char *rec, XICAttribute *list, int need_swap)
301 extern XimFrameRec xpoint_fr[];
302 XPoint *rect = (XPoint *) list->value;
303 unsigned char *recp = (unsigned char *) rec;
305 GetAttrHeader (recp, list, need_swap);
306 recp += sizeof(CARD16)*2;
308 fm = FrameMgrInit (xpoint_fr, (char *) recp, need_swap);
310 FrameMgrPutToken (fm, rect->x);
311 FrameMgrPutToken (fm, rect->y);
315 static int ReadICValue (Xi18n i18n_core,
319 XICAttribute *value_ret,
324 XICAttr *ic_attr = i18n_core->address.xic_attr;
327 *number_ret = (CARD16) 0;
329 for (i = 0; i < i18n_core->address.ic_attr_num; i++, ic_attr++)
331 if (ic_attr->attribute_id == icvalue_id)
336 switch (ic_attr->type)
340 int total_length = 0;
342 INT16 attribute_length;
343 unsigned char *p1 = (unsigned char *) p;
347 extern XimFrameRec attr_head_fr[];
349 while (total_length < value_length)
351 fm = FrameMgrInit (attr_head_fr, (char *) p1, need_swap);
353 FrameMgrGetToken (fm, attribute_ID);
354 FrameMgrGetToken (fm, attribute_length);
356 p1 += sizeof (CARD16)*2;
357 ReadICValue (i18n_core,
361 (value_ret + 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);
381 SetCardAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
382 *number_ret = (CARD16) 1;
385 case XimType_XFontSet:
386 SetFontAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
387 *number_ret = (CARD16) 1;
390 case XimType_XRectangle:
391 SetRectAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
392 *number_ret = (CARD16) 1;
396 SetPointAttribute(value_ret, p, ic_attr, value_length, need_swap, value_buf);
397 *number_ret = (CARD16) 1;
401 case XimType_XIMHotKeyTriggers:
402 SetHotKeyAttribute (value_ret, p, ic_attr, value_length, need_swap, value_buf);
403 *number_ret = (CARD16) 1;
411 static XICAttribute *CreateNestedList (CARD16 attr_id,
416 XICAttribute *nest_list = NULL;
420 int value_length = 0;
425 for (i = 0; i < number; i++)
427 value_length += sizeof (CARD16)*2;
428 value_length += list[i].value_length;
429 value_length += IMPAD (list[i].value_length);
432 if ((values = (char *) malloc (value_length)) == NULL)
435 memset (values, 0, value_length);
438 for (i = 0; i < number; i++)
440 switch (list[i].type)
446 GetCardAttribute (valuesp, &list[i], need_swap);
449 case XimType_XFontSet:
450 GetFontAttribute (valuesp, &list[i], need_swap);
453 case XimType_XRectangle:
454 GetRectAttribute (valuesp, &list[i], need_swap);
458 GetPointAttribute (valuesp, &list[i], need_swap);
462 case XimType_XIMHotKeyTriggers:
463 GetHotKeyAttribute (valuesp, &list[i], need_swap);
468 valuesp += sizeof (CARD16)*2;
469 valuesp += list[i].value_length;
470 valuesp += IMPAD(list[i].value_length);
474 nest_list = (XICAttribute *) malloc (sizeof (XICAttribute));
475 if (nest_list == NULL)
478 memset (nest_list, 0, sizeof (XICAttribute));
479 nest_list->value = (void *) malloc (value_length);
480 if (nest_list->value == NULL)
483 memset (nest_list->value, 0, sizeof (value_length));
485 nest_list->attribute_id = attr_id;
486 nest_list->value_length = value_length;
487 memmove (nest_list->value, values, value_length);
493 static Bool IsNestedList (Xi18n i18n_core, CARD16 icvalue_id)
495 XICAttr *ic_attr = i18n_core->address.xic_attr;
498 for (i = 0; i < i18n_core->address.ic_attr_num; i++, ic_attr++)
500 if (ic_attr->attribute_id == icvalue_id)
502 if (ic_attr->type == XimType_NEST)
513 static Bool IsSeparator (Xi18n i18n_core, CARD16 icvalue_id)
515 return (i18n_core->address.separatorAttr_id == icvalue_id);
518 static int GetICValue (Xi18n i18n_core,
519 XICAttribute *attr_ret,
523 XICAttr *xic_attr = i18n_core->address.xic_attr;
530 if (IsNestedList (i18n_core, id_list[i]))
533 while (i < list_num && !IsSeparator (i18n_core, id_list[i]))
535 for (j = 0; j < i18n_core->address.ic_attr_num; j++)
537 if (xic_attr[j].attribute_id == id_list[i])
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;
556 for (j = 0; j < i18n_core->address.ic_attr_num; j++)
558 if (xic_attr[j].attribute_id == id_list[i])
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;
576 static void SwapAttributes (XICAttribute *list,
580 extern XimFrameRec short_fr[];
582 extern XimFrameRec long_fr[];
584 extern XimFrameRec xpoint_fr[];
586 extern XimFrameRec xrectangle_fr[];
589 for (i = 0; i < number; ++i, ++list) {
590 if (list->value == NULL)
592 switch (list->type) {
594 fm = FrameMgrInit (short_fr, (char *)list->value, 1);
595 FrameMgrGetToken (fm, c16);
596 memmove(list->value, &c16, sizeof(CARD16));
601 fm = FrameMgrInit (long_fr, (char *)list->value, 1);
602 FrameMgrGetToken (fm, c32);
603 memmove(list->value, &c32, sizeof(CARD32));
606 case XimType_XRectangle:
607 fm = FrameMgrInit (xrectangle_fr, (char *)list->value, 1);
608 FrameMgrGetToken (fm, xrect);
609 memmove(list->value, &xrect, sizeof(XRectangle));
613 fm = FrameMgrInit (xpoint_fr, (char *)list->value, 1);
614 FrameMgrGetToken (fm, xpoint);
615 memmove(list->value, &xpoint, sizeof(XPoint));
624 /* called from CreateICMessageProc and SetICValueMessageProc */
625 void _Xi18nChangeIC (XIMS ims,
626 IMProtocol *call_data,
630 Xi18n i18n_core = ims->protocol;
634 register int total_size;
635 unsigned char *reply = NULL;
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;
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;
653 void *value_buf = NULL;
656 register int total_value_length = 0;
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);
662 if (create_flag == True)
664 fm = FrameMgrInit (create_ic_fr,
666 _Xi18nNeedSwap (i18n_core, connect_id));
668 FrameMgrGetToken (fm, input_method_ID);
669 FrameMgrGetToken (fm, byte_length);
673 fm = FrameMgrInit (set_ic_values_fr,
675 _Xi18nNeedSwap (i18n_core, connect_id));
677 FrameMgrGetToken (fm, input_method_ID);
678 FrameMgrGetToken (fm, changeic->icid);
679 FrameMgrGetToken (fm, byte_length);
682 attrib_list = (XICAttribute *) malloc (sizeof (XICAttribute)*IC_SIZE);
685 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
689 memset (attrib_list, 0, sizeof(XICAttribute)*IC_SIZE);
692 while (FrameMgrIsIterLoopEnd (fm, &status) == False)
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';
706 total_value_length += (value_length + 1);
710 value_buf = (void *) malloc (total_value_length);
711 value_buf_ptr = value_buf;
715 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
716 for (i = 0; i < attrib_num; i++)
717 XFree (attrib_list[i].value);
724 for (i = 0; i < attrib_num; i++)
728 if (IsNestedList (i18n_core, attrib_list[i].attribute_id))
730 if (attrib_list[i].attribute_id
731 == i18n_core->address.preeditAttr_id)
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],
739 _Xi18nNeedSwap(i18n_core, connect_id),
741 preedit_ic_num += number;
743 else if (attrib_list[i].attribute_id == i18n_core->address.statusAttr_id)
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],
751 _Xi18nNeedSwap (i18n_core, connect_id),
753 status_ic_num += number;
757 /* another nested list.. possible? */
763 ReadICValue (i18n_core,
764 attrib_list[i].attribute_id,
765 attrib_list[i].value_length,
766 attrib_list[i].value,
769 _Xi18nNeedSwap (i18n_core, connect_id),
776 for (i = 0; i < attrib_num; i++)
777 XFree (attrib_list[i].value);
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;
790 if (i18n_core->address.improto)
792 if (!(i18n_core->address.improto(ims, call_data))) {
802 if (create_flag == True)
804 fm = FrameMgrInit (create_ic_reply_fr,
806 _Xi18nNeedSwap (i18n_core, connect_id));
810 fm = FrameMgrInit (set_ic_values_reply_fr,
812 _Xi18nNeedSwap (i18n_core, connect_id));
815 total_size = FrameMgrGetTotalSize (fm);
816 reply = (unsigned char *) malloc (total_size);
820 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
824 memset (reply, 0, total_size);
825 FrameMgrSetBuffer (fm, reply);
827 FrameMgrPutToken (fm, input_method_ID);
828 FrameMgrPutToken (fm, changeic->icid);
830 if (create_flag == True)
832 _Xi18nSendMessage (ims,
841 _Xi18nSendMessage (ims,
843 XIM_SET_IC_VALUES_REPLY,
849 if (create_flag == True)
851 int on_key_num = i18n_core->address.on_keys.count_keys;
852 int off_key_num = i18n_core->address.off_keys.count_keys;
854 if (on_key_num == 0 && off_key_num == 0)
858 if (i18n_core->address.imvalue_mask & I18N_FILTERMASK)
859 mask = i18n_core->address.filterevent_mask;
861 mask = DEFAULT_FILTER_MASK;
863 /* static event flow is default */
864 _Xi18nSetEventMask (ims,
878 /* called from GetICValueMessageProc */
879 void _Xi18nGetIC (XIMS ims, IMProtocol *call_data, unsigned char *p)
881 Xi18n i18n_core = ims->protocol;
884 extern XimFrameRec get_ic_values_fr[];
885 extern XimFrameRec get_ic_values_reply_fr[];
887 register int total_size;
888 unsigned char *reply = NULL;
889 XICAttribute *preedit_ret = NULL;
890 XICAttribute *status_ret = NULL;
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;
901 IMChangeICStruct *getic = (IMChangeICStruct *) &call_data->changeic;
902 CARD16 connect_id = call_data->any.connect_id;
903 CARD16 input_method_ID;
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);
909 fm = FrameMgrInit (get_ic_values_fr,
911 _Xi18nNeedSwap (i18n_core, connect_id));
914 FrameMgrGetToken (fm, input_method_ID);
915 FrameMgrGetToken (fm, getic->icid);
916 FrameMgrGetToken (fm, byte_length);
918 attrID_list = (CARD16 *) malloc (sizeof (CARD16)*IC_SIZE); /* bogus */
919 memset (attrID_list, 0, sizeof (CARD16)*IC_SIZE);
922 while (FrameMgrIsIterLoopEnd (fm, &status) == False)
923 FrameMgrGetToken (fm, attrID_list[number++]);
932 if (IsNestedList (i18n_core, attrID_list[i]))
934 if (attrID_list[i] == i18n_core->address.preeditAttr_id)
936 read_number = GetICValue (i18n_core,
937 &pre_attr[pre_count],
940 i += read_number + 1;
941 pre_count += read_number;
943 else if (attrID_list[i] == i18n_core->address.statusAttr_id)
945 read_number = GetICValue (i18n_core,
946 &sts_attr[sts_count],
949 i += read_number + 1;
950 sts_count += read_number;
954 /* another nested list.. possible? */
960 read_number = GetICValue (i18n_core,
965 ic_count += read_number;
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)
978 if (!(i18n_core->address.improto (ims, call_data)))
981 if (_Xi18nNeedSwap (i18n_core, connect_id))
982 SwapAttributes(getic->ic_attr, getic->ic_attr_num);
985 iter_count = getic->ic_attr_num;
987 preedit_ret = CreateNestedList (i18n_core->address.preeditAttr_id,
989 getic->preedit_attr_num,
990 _Xi18nNeedSwap (i18n_core, connect_id));
994 status_ret = CreateNestedList (i18n_core->address.statusAttr_id,
996 getic->status_attr_num,
997 _Xi18nNeedSwap (i18n_core, connect_id));
1002 fm = FrameMgrInit (get_ic_values_reply_fr,
1004 _Xi18nNeedSwap (i18n_core, connect_id));
1006 /* set iteration count for list of ic_attribute */
1007 FrameMgrSetIterCount (fm, iter_count);
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);
1015 FrameMgrSetSize (fm, preedit_ret->value_length);
1018 FrameMgrSetSize (fm, status_ret->value_length);
1020 total_size = FrameMgrGetTotalSize (fm);
1021 reply = (unsigned char *) malloc (total_size);
1024 _Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
1028 memset (reply, 0, total_size);
1029 FrameMgrSetBuffer (fm, reply);
1031 FrameMgrPutToken (fm, input_method_ID);
1032 FrameMgrPutToken (fm, getic->icid);
1034 for (i = 0; i < (int) getic->ic_attr_num; i++)
1036 FrameMgrPutToken (fm, ic_attr[i].attribute_id);
1037 FrameMgrPutToken (fm, ic_attr[i].value_length);
1038 FrameMgrPutToken (fm, ic_attr[i].value);
1043 FrameMgrPutToken (fm, preedit_ret->attribute_id);
1044 FrameMgrPutToken (fm, preedit_ret->value_length);
1045 FrameMgrPutToken (fm, preedit_ret->value);
1050 FrameMgrPutToken (fm, status_ret->attribute_id);
1051 FrameMgrPutToken (fm, status_ret->value_length);
1052 FrameMgrPutToken (fm, status_ret->value);
1055 _Xi18nSendMessage (ims,
1057 XIM_GET_IC_VALUES_REPLY,
1062 XFree (attrID_list);
1064 for (i = 0; i < (int) getic->ic_attr_num; i++)
1066 if (getic->ic_attr[i].name)
1067 XFree (getic->ic_attr[i].name);
1069 if (getic->ic_attr[i].value)
1070 XFree (getic->ic_attr[i].value);
1074 for (i = 0; i < (int) getic->preedit_attr_num; i++)
1076 if (getic->preedit_attr[i].name)
1077 XFree (getic->preedit_attr[i].name);
1079 if (getic->preedit_attr[i].value)
1080 XFree (getic->preedit_attr[i].value);
1084 for (i = 0; i < (int) getic->status_attr_num; i++)
1086 if (getic->status_attr[i].name)
1087 XFree (getic->status_attr[i].name);
1089 if (getic->status_attr[i].value)
1090 XFree (getic->status_attr[i].value);
1097 XFree (preedit_ret->value);
1098 XFree (preedit_ret);
1103 XFree (status_ret->value);