From 3562e78743202e43aec8727005182a2558117eca Mon Sep 17 00:00:00 2001 From: marha Date: Sun, 28 Jun 2009 22:07:26 +0000 Subject: Checked in the following released items: xkeyboard-config-1.4.tar.gz ttf-bitstream-vera-1.10.tar.gz font-alias-1.0.1.tar.gz font-sun-misc-1.0.0.tar.gz font-sun-misc-1.0.0.tar.gz font-sony-misc-1.0.0.tar.gz font-schumacher-misc-1.0.0.tar.gz font-mutt-misc-1.0.0.tar.gz font-misc-misc-1.0.0.tar.gz font-misc-meltho-1.0.0.tar.gz font-micro-misc-1.0.0.tar.gz font-jis-misc-1.0.0.tar.gz font-isas-misc-1.0.0.tar.gz font-dec-misc-1.0.0.tar.gz font-daewoo-misc-1.0.0.tar.gz font-cursor-misc-1.0.0.tar.gz font-arabic-misc-1.0.0.tar.gz font-winitzki-cyrillic-1.0.0.tar.gz font-misc-cyrillic-1.0.0.tar.gz font-cronyx-cyrillic-1.0.0.tar.gz font-screen-cyrillic-1.0.1.tar.gz font-xfree86-type1-1.0.1.tar.gz font-adobe-utopia-type1-1.0.1.tar.gz font-ibm-type1-1.0.0.tar.gz font-bitstream-type1-1.0.0.tar.gz font-bitstream-speedo-1.0.0.tar.gz font-bh-ttf-1.0.0.tar.gz font-bh-type1-1.0.0.tar.gz font-bitstream-100dpi-1.0.0.tar.gz font-bh-lucidatypewriter-100dpi-1.0.0.tar.gz font-bh-100dpi-1.0.0.tar.gz font-adobe-utopia-100dpi-1.0.1.tar.gz font-adobe-100dpi-1.0.0.tar.gz font-util-1.0.1.tar.gz font-bitstream-75dpi-1.0.0.tar.gz font-bh-lucidatypewriter-75dpi-1.0.0.tar.gz font-adobe-utopia-75dpi-1.0.1.tar.gz font-bh-75dpi-1.0.0.tar.gz bdftopcf-1.0.1.tar.gz font-adobe-75dpi-1.0.0.tar.gz mkfontscale-1.0.6.tar.gz openssl-0.9.8k.tar.gz bigreqsproto-1.0.2.tar.gz xtrans-1.2.2.tar.gz resourceproto-1.0.2.tar.gz inputproto-1.4.4.tar.gz compositeproto-0.4.tar.gz damageproto-1.1.0.tar.gz zlib-1.2.3.tar.gz xkbcomp-1.0.5.tar.gz freetype-2.3.9.tar.gz pthreads-w32-2-8-0-release.tar.gz pixman-0.12.0.tar.gz kbproto-1.0.3.tar.gz evieext-1.0.2.tar.gz fixesproto-4.0.tar.gz recordproto-1.13.2.tar.gz randrproto-1.2.2.tar.gz scrnsaverproto-1.1.0.tar.gz renderproto-0.9.3.tar.gz xcmiscproto-1.1.2.tar.gz fontsproto-2.0.2.tar.gz xextproto-7.0.3.tar.gz xproto-7.0.14.tar.gz libXdmcp-1.0.2.tar.gz libxkbfile-1.0.5.tar.gz libfontenc-1.0.4.tar.gz libXfont-1.3.4.tar.gz libX11-1.1.5.tar.gz libXau-1.0.4.tar.gz libxcb-1.1.tar.gz xorg-server-1.5.3.tar.gz --- libX11/modules/im/ximcp/imRmAttr.c | 1517 ++++++++++++++++++++++++++++++++++++ 1 file changed, 1517 insertions(+) create mode 100644 libX11/modules/im/ximcp/imRmAttr.c (limited to 'libX11/modules/im/ximcp/imRmAttr.c') diff --git a/libX11/modules/im/ximcp/imRmAttr.c b/libX11/modules/im/ximcp/imRmAttr.c new file mode 100644 index 000000000..af4db3db0 --- /dev/null +++ b/libX11/modules/im/ximcp/imRmAttr.c @@ -0,0 +1,1517 @@ +/* $Xorg: imRmAttr.c,v 1.4 2000/08/17 19:45:15 cpqbld Exp $ */ +/****************************************************************** + + Copyright 1992, 1993, 1994 by FUJITSU LIMITED + +Permission to use, copy, modify, distribute, and sell this software +and its documentation for any purpose is hereby granted without fee, +provided that the above copyright notice appear in all copies and +that both that copyright notice and this permission notice appear +in supporting documentation, and that the name of FUJITSU LIMITED +not be used in advertising or publicity pertaining to distribution +of the software without specific, written prior permission. +FUJITSU LIMITED makes no representations about the suitability of +this software for any purpose. +It is provided "as is" without express or implied warranty. + +FUJITSU LIMITED DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL FUJITSU LIMITED BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + + Author: Takashi Fujiwara FUJITSU LIMITED + fujiwara@a80.tech.yk.fujitsu.co.jp + +******************************************************************/ +/* $XFree86: xc/lib/X11/imRmAttr.c,v 1.7 2003/04/13 19:22:21 dawes Exp $ */ + +#ifdef HAVE_CONFIG_H +#include +#endif +#include "Xlibint.h" +#include "Xlcint.h" +#include "Ximint.h" + + +Private XIMResourceList +_XimGetNestedListSeparator( + XIMResourceList res_list, /* LISTofIMATTR or IMATTR */ + unsigned int res_num) +{ + return _XimGetResourceListRec(res_list, res_num, XNSeparatorofNestedList); +} + +Private Bool +_XimCheckInnerIMAttributes( + Xim im, + XIMArg *arg, + unsigned long mode) +{ + XIMResourceList res; + int check; + + if (!(res = _XimGetResourceListRec(im->private.proto.im_inner_resources, + im->private.proto.im_num_inner_resources, arg->name))) + return False; + + check = _XimCheckIMMode(res, mode); + if(check == XIM_CHECK_INVALID) + return True; + else if(check == XIM_CHECK_ERROR) + return False; + + return True; +} + +Public char * +_XimMakeIMAttrIDList( + Xim im, + XIMResourceList res_list, + unsigned int res_num, + XIMArg *arg, + CARD16 *buf, + INT16 *len, + unsigned long mode) +{ + register XIMArg *p; + XIMResourceList res; + int check; + + *len = 0; + if (!arg) + return (char *)NULL; + + for (p = arg; p->name; p++) { + if (!(res = _XimGetResourceListRec(res_list, res_num, p->name))) { + if (_XimCheckInnerIMAttributes(im, p, mode)) + continue; + return p->name; + } + + check = _XimCheckIMMode(res, mode); + if (check == XIM_CHECK_INVALID) + continue; + else if (check == XIM_CHECK_ERROR) + return p->name; + + *buf = res->id; + *len += sizeof(CARD16); + buf++; + } + return (char *)NULL; +} + +Private Bool +_XimCheckInnerICAttributes( + Xic ic, + XIMArg *arg, + unsigned long mode) +{ + XIMResourceList res; + int check; + + if (!(res = _XimGetResourceListRec(ic->private.proto.ic_inner_resources, + ic->private.proto.ic_num_inner_resources, arg->name))) + return False; + + check = _XimCheckICMode(res, mode); + if(check == XIM_CHECK_INVALID) + return True; + else if(check == XIM_CHECK_ERROR) + return False; + + return True; +} + +Public char * +_XimMakeICAttrIDList( + Xic ic, + XIMResourceList res_list, + unsigned int res_num, + XIMArg *arg, + CARD16 *buf, + INT16 *len, + unsigned long mode) +{ + register XIMArg *p; + XIMResourceList res; + int check; + XrmQuark pre_quark; + XrmQuark sts_quark; + char *name; + INT16 new_len; + + *len = 0; + if (!arg) + return (char *)NULL; + + pre_quark = XrmStringToQuark(XNPreeditAttributes); + sts_quark = XrmStringToQuark(XNStatusAttributes); + + for (p = arg; p && p->name; p++) { + if (!(res = _XimGetResourceListRec(res_list, res_num, p->name))) { + if (_XimCheckInnerICAttributes(ic, p, mode)) + continue; + *len = -1; + return p->name; + } + + check = _XimCheckICMode(res, mode); + if(check == XIM_CHECK_INVALID) + continue; + else if(check == XIM_CHECK_ERROR) { + *len = -1; + return p->name; + } + + *buf = res->id; + *len += sizeof(CARD16); + buf++; + if (res->resource_size == XimType_NEST) { + if (res->xrm_name == pre_quark) { + if ((name = _XimMakeICAttrIDList(ic, res_list, res_num, + (XIMArg *)p->value, buf, &new_len, + (mode | XIM_PREEDIT_ATTR)))) { + if (new_len < 0) *len = -1; + else *len += new_len; + return name; + } + } else if (res->xrm_name == sts_quark) { + if ((name = _XimMakeICAttrIDList(ic, res_list, res_num, + (XIMArg *)p->value, buf, &new_len, + (mode | XIM_STATUS_ATTR)))) { + if (new_len < 0) *len = -1; + else *len += new_len; + return name; + } + } + *len += new_len; + buf = (CARD16 *)((char *)buf + new_len); + if (!(res = _XimGetNestedListSeparator(res_list, res_num))) { + p++; + if (p) { + *len = -1; + return p->name; + } + else { + return (char *)NULL; + } + } + *buf = res->id; + *len += sizeof(CARD16); + buf++; + } + } + return (char *)NULL; +} + +Private Bool +_XimAttributeToValue( + Xic ic, + XIMResourceList res, + CARD16 *data, + INT16 data_len, + XPointer value, + BITMASK32 mode) +{ + switch (res->resource_size) { + case XimType_SeparatorOfNestedList: + case XimType_NEST: + break; + + case XimType_CARD8: + case XimType_CARD16: + case XimType_CARD32: + case XimType_Window: + case XimType_XIMHotKeyState: + _XCopyToArg((XPointer)data, (XPointer *)&value, data_len); + break; + + case XimType_STRING8: + { + char *str; + + if (!(value)) + return False; + + if (!(str = (char *)Xmalloc(data_len + 1))) + return False; + + (void)memcpy(str, (char *)data, data_len); + str[data_len] = '\0'; + + *((char **)value) = str; + break; + } + + case XimType_XIMStyles: + { + INT16 num = data[0]; + register CARD32 *style_list = (CARD32 *)&data[2]; + XIMStyle *style; + XIMStyles *rep; + register int i; + char *p; + int alloc_len; + + if (!(value)) + return False; + + alloc_len = sizeof(XIMStyles) + sizeof(XIMStyle) * num; + if (!(p = (char *)Xmalloc(alloc_len))) + return False; + + rep = (XIMStyles *)p; + style = (XIMStyle *)(p + sizeof(XIMStyles)); + + for (i = 0; i < num; i++) + style[i] = (XIMStyle)style_list[i]; + + rep->count_styles = (unsigned short)num; + rep->supported_styles = style; + *((XIMStyles **)value) = rep; + break; + } + + case XimType_XRectangle: + { + XRectangle *rep; + + if (!(value)) + return False; + + if (!(rep = (XRectangle *)Xmalloc(sizeof(XRectangle)))) + return False; + + rep->x = data[0]; + rep->y = data[1]; + rep->width = data[2]; + rep->height = data[3]; + *((XRectangle **)value) = rep; + break; + } + + case XimType_XPoint: + { + XPoint *rep; + + if (!(value)) + return False; + + if (!(rep = (XPoint *)Xmalloc(sizeof(XPoint)))) + return False; + + rep->x = data[0]; + rep->y = data[1]; + *((XPoint **)value) = rep; + break; + } + + case XimType_XFontSet: + { + INT16 len = data[0]; + char *base_name; + XFontSet rep = (XFontSet)NULL; + char **missing_list; + int missing_count; + char *def_string; + + if (!(value)) + return False; + if (!ic) + return False; + + if (!(base_name = (char *)Xmalloc(len + 1))) + return False; + + (void)strncpy(base_name, (char *)&data[1], (int)len); + base_name[len] = '\0'; + + if (mode & XIM_PREEDIT_ATTR) { + if (!strcmp(base_name, ic->private.proto.preedit_font)) { + rep = ic->core.preedit_attr.fontset; + } else if (!ic->private.proto.preedit_font_length) { + rep = XCreateFontSet(ic->core.im->core.display, + base_name, &missing_list, + &missing_count, &def_string); + } + } else if (mode & XIM_STATUS_ATTR) { + if (!strcmp(base_name, ic->private.proto.status_font)) { + rep = ic->core.status_attr.fontset; + } else if (!ic->private.proto.status_font_length) { + rep = XCreateFontSet(ic->core.im->core.display, + base_name, &missing_list, + &missing_count, &def_string); + } + } + + Xfree(base_name); + *((XFontSet *)value) = rep; + break; + } + + case XimType_XIMHotKeyTriggers: + { + INT32 num = *((CARD32 *)data); + register CARD32 *key_list = (CARD32 *)&data[2]; + XIMHotKeyTrigger *key; + XIMHotKeyTriggers *rep; + register int i; + char *p; + int alloc_len; + + if (!(value)) + return False; + + alloc_len = sizeof(XIMHotKeyTriggers) + + sizeof(XIMHotKeyTrigger) * num; + if (!(p = (char *)Xmalloc(alloc_len))) + return False; + + rep = (XIMHotKeyTriggers *)p; + key = (XIMHotKeyTrigger *)(p + sizeof(XIMHotKeyTriggers)); + + for (i = 0; i < num; i++, key_list += 3) { + key[i].keysym = (KeySym)key_list[0]; /* keysym */ + key[i].modifier = (int)key_list[1]; /* modifier */ + key[i].modifier_mask = (int)key_list[2]; /* modifier_mask */ + } + + rep->num_hot_key = (int)num; + rep->key = key; + *((XIMHotKeyTriggers **)value) = rep; + break; + } + + case XimType_XIMStringConversion: + { + break; + } + + default: + return False; + } + return True; +} + +Private Bool +_XimDecodeInnerIMATTRIBUTE( + Xim im, + XIMArg *arg) +{ + XIMResourceList res; + XimDefIMValues im_values; + + if (!(res = _XimGetResourceListRec(im->private.proto.im_inner_resources, + im->private.proto.im_num_inner_resources, arg->name))) + return False; + + _XimGetCurrentIMValues(im, &im_values); + return _XimDecodeLocalIMAttr(res, (XPointer)&im_values, arg->value); +} + +Public char * +_XimDecodeIMATTRIBUTE( + Xim im, + XIMResourceList res_list, + unsigned int res_num, + CARD16 *data, + INT16 data_len, + XIMArg *arg, + BITMASK32 mode) +{ + register XIMArg *p; + XIMResourceList res; + int check; + INT16 len; + CARD16 *buf; + INT16 total; + INT16 min_len = sizeof(CARD16) /* sizeof attributeID */ + + sizeof(INT16); /* sizeof length */ + + for (p = arg; p->name; p++) { + if (!(res = _XimGetResourceListRec(res_list, res_num, p->name))) { + if (_XimDecodeInnerIMATTRIBUTE(im, p)) + continue; + return p->name; + } + + check = _XimCheckIMMode(res, mode); + if(check == XIM_CHECK_INVALID) + continue; + else if(check == XIM_CHECK_ERROR) + return p->name; + + total = data_len; + buf = data; + while (total >= min_len) { + if (res->id == buf[0]) + break; + + len = buf[1]; + len += XIM_PAD(len) + min_len; + buf = (CARD16 *)((char *)buf + len); + total -= len; + } + if (total < min_len) + return p->name; + + if (!(_XimAttributeToValue((Xic) im->private.local.current_ic, + res, &buf[2], buf[1], p->value, mode))) + return p->name; + } + return (char *)NULL; +} + +Private Bool +_XimDecodeInnerICATTRIBUTE( + Xic ic, + XIMArg *arg, + unsigned long mode) +{ + XIMResourceList res; + XimDefICValues ic_values; + + if (!(res = _XimGetResourceListRec(ic->private.proto.ic_inner_resources, + ic->private.proto.ic_num_inner_resources, arg->name))) + return False; + + _XimGetCurrentICValues(ic, &ic_values); + if (!_XimDecodeLocalICAttr(res, (XPointer)&ic_values, arg->value, mode)) + return False; + _XimSetCurrentICValues(ic, &ic_values); + return True; +} + +Public char * +_XimDecodeICATTRIBUTE( + Xic ic, + XIMResourceList res_list, + unsigned int res_num, + CARD16 *data, + INT16 data_len, + XIMArg *arg, + BITMASK32 mode) +{ + register XIMArg *p; + XIMResourceList res; + int check; + INT16 len; + CARD16 *buf; + INT16 total; + char *name; + INT16 min_len = sizeof(CARD16) /* sizeof attributeID */ + + sizeof(INT16); /* sizeof length */ + XrmQuark pre_quark; + XrmQuark sts_quark; + + if (!arg) + return (char *)NULL; + + pre_quark = XrmStringToQuark(XNPreeditAttributes); + sts_quark = XrmStringToQuark(XNStatusAttributes); + + for (p = arg; p->name; p++) { + if (!(res = _XimGetResourceListRec(res_list, res_num, p->name))) { + if (_XimDecodeInnerICATTRIBUTE(ic, p, mode)) + continue; + return p->name; + } + + check = _XimCheckICMode(res, mode); + if (check == XIM_CHECK_INVALID) + continue; + else if (check == XIM_CHECK_ERROR) + return p->name; + + total = data_len; + buf = data; + while (total >= min_len) { + if (res->id == buf[0]) + break; + + len = buf[1]; + len += XIM_PAD(len) + min_len; + buf = (CARD16 *)((char *)buf + len); + total -= len; + } + if (total < min_len) + return p->name; + + if (res->resource_size == XimType_NEST) { + if (res->xrm_name == pre_quark) { + if ((name = _XimDecodeICATTRIBUTE(ic, res_list, res_num, + &buf[2], buf[1], (XIMArg *)p->value, + (mode | XIM_PREEDIT_ATTR)))) + return name; + } else if (res->xrm_name == sts_quark) { + if ((name = _XimDecodeICATTRIBUTE(ic, res_list, res_num, + &buf[2], buf[1], (XIMArg *)p->value, + (mode | XIM_STATUS_ATTR)))) + return name; + } + } else { + if (!(_XimAttributeToValue(ic, res, &buf[2], buf[1], + p->value, mode))) + return p->name; + } + } + return (char *)NULL; +} + +Private Bool +_XimValueToAttribute( + XIMResourceList res, + XPointer buf, + int buf_size, + XPointer value, + int *len, + unsigned long mode, + XPointer param) +{ + int ret_len; + + switch (res->resource_size) { + case XimType_SeparatorOfNestedList: + case XimType_NEST: + *len = 0; + break; + + case XimType_CARD8: + ret_len = sizeof(CARD8); + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + *((CARD8 *)buf) = (CARD8)(long)value; + *len = ret_len; + break; + + case XimType_CARD16: + ret_len = sizeof(CARD16); + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + *((CARD16 *)buf) = (CARD16)(long)value; + *len = ret_len; + break; + + case XimType_CARD32: + case XimType_Window: + case XimType_XIMHotKeyState: + ret_len = sizeof(CARD32); + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + *((CARD32 *)buf) = (CARD32)(long)value; + *len = ret_len; + break; + + case XimType_STRING8: + if (!value) { + *len = 0; + return False; + } + + ret_len = strlen((char *)value); + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + (void)memcpy((char *)buf, (char *)value, ret_len); + *len = ret_len; + break; + + case XimType_XRectangle: + { + XRectangle *rect = (XRectangle *)value; + CARD16 *buf_s = (CARD16 *)buf; + + if (!rect) { + *len = 0; + return False; + } + + ret_len = sizeof(INT16) /* sizeof X */ + + sizeof(INT16) /* sizeof Y */ + + sizeof(CARD16) /* sizeof width */ + + sizeof(CARD16); /* sizeof height */ + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + buf_s[0] = (CARD16)rect->x; /* X */ + buf_s[1] = (CARD16)rect->y; /* Y */ + buf_s[2] = (CARD16)rect->width; /* width */ + buf_s[3] = (CARD16)rect->height; /* heght */ + *len = ret_len; + break; + } + + case XimType_XPoint: + { + XPoint *point = (XPoint *)value; + CARD16 *buf_s = (CARD16 *)buf; + + if (!point) { + *len = 0; + return False; + } + + ret_len = sizeof(INT16) /* sizeof X */ + + sizeof(INT16); /* sizeof Y */ + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + buf_s[0] = (CARD16)point->x; /* X */ + buf_s[1] = (CARD16)point->y; /* Y */ + *len = ret_len; + break; + } + + case XimType_XFontSet: + { + XFontSet font = (XFontSet)value; + Xic ic = (Xic)param; + char *base_name = NULL; + int length = 0; + CARD16 *buf_s = (CARD16 *)buf; + + if (!font) { + *len = 0; + return False; + } + + if (mode & XIM_PREEDIT_ATTR) { + base_name = ic->private.proto.preedit_font; + length = ic->private.proto.preedit_font_length; + } else if (mode & XIM_STATUS_ATTR) { + base_name = ic->private.proto.status_font; + length = ic->private.proto.status_font_length; + } + + if (!base_name) { + *len = 0; + return False; + } + + ret_len = sizeof(CARD16) /* sizeof length of Base name */ + + length; /* sizeof Base font name list */ + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + buf_s[0] = (INT16)length; /* length of Base font name */ + (void)memcpy((char *)&buf_s[1], base_name, length); + /* Base font name list */ + *len = ret_len; + break; + } + + case XimType_XIMHotKeyTriggers: + { + XIMHotKeyTriggers *hotkey = (XIMHotKeyTriggers *)value; + INT32 num; + CARD32 *buf_l = (CARD32 *)buf; + register CARD32 *key = (CARD32 *)&buf_l[1]; + register int i; + + if (!hotkey) { + *len = 0; + return False; + } + num = (INT32)hotkey->num_hot_key; + + ret_len = sizeof(INT32) /* sizeof number of key list */ + + (sizeof(CARD32) /* sizeof keysyn */ + + sizeof(CARD32) /* sizeof modifier */ + + sizeof(CARD32)) /* sizeof modifier_mask */ + * num; /* number of key list */ + if (buf_size < ret_len + XIM_PAD(ret_len)) { + *len = -1; + return False; + } + + buf_l[0] = num; /* number of key list */ + for (i = 0; i < num; i++, key += 3) { + key[0] = (CARD32)(hotkey->key[i].keysym); + /* keysym */ + key[1] = (CARD32)(hotkey->key[i].modifier); + /* modifier */ + key[2] = (CARD32)(hotkey->key[i].modifier_mask); + /* modifier_mask */ + } + *len = ret_len; + break; + } + + case XimType_XIMStringConversion: + { + *len = 0; + break; + } + + default: + return False; + } + return True; +} + +Private Bool +_XimSetInnerIMAttributes( + Xim im, + XPointer top, + XIMArg *arg, + unsigned long mode) +{ + XIMResourceList res; + int check; + + if (!(res = _XimGetResourceListRec(im->private.proto.im_inner_resources, + im->private.proto.im_num_inner_resources, arg->name))) + return False; + + check = _XimCheckIMMode(res, mode); + if(check == XIM_CHECK_INVALID) + return True; + else if(check == XIM_CHECK_ERROR) + return False; + + return _XimEncodeLocalIMAttr(res, top, arg->value); +} + +Public char * +_XimEncodeIMATTRIBUTE( + Xim im, + XIMResourceList res_list, + unsigned int res_num, + XIMArg *arg, + XIMArg **arg_ret, + char *buf, + int size, + int *ret_len, + XPointer top, + unsigned long mode) +{ + register XIMArg *p; + XIMResourceList res; + int check; + CARD16 *buf_s; + int len; + int min_len = sizeof(CARD16) /* sizeof attribute ID */ + + sizeof(INT16); /* sizeof value length */ + + *ret_len = 0; + for (p = arg; p->name; p++) { + if (!(res = _XimGetResourceListRec(res_list, res_num, p->name))) { + if (_XimSetInnerIMAttributes(im, top, p, mode)) + continue; + return p->name; + } + + check = _XimCheckIMMode(res, mode); + if (check == XIM_CHECK_INVALID) + continue; + else if (check == XIM_CHECK_ERROR) + return p->name; + + if (!(_XimEncodeLocalIMAttr(res, top, p->value))) + return p->name; + + buf_s = (CARD16 *)buf; + if (!(_XimValueToAttribute(res, (XPointer)&buf_s[2], (size - min_len), + p->value, &len, mode, (XPointer)NULL))) + return p->name; + + if (len == 0) { + continue; + } else if (len < 0) { + *arg_ret = p; + return (char *)NULL; + } + + buf_s[0] = res->id; /* attribute ID */ + buf_s[1] = len; /* value length */ + XIM_SET_PAD(&buf_s[2], len); /* pad */ + len += min_len; + + buf += len; + *ret_len += len; + size -= len; + } + *arg_ret = (XIMArg *)NULL; + return (char *)NULL; +} + +#ifdef XIM_CONNECTABLE +Public Bool +_XimEncodeSavedIMATTRIBUTE( + Xim im, + XIMResourceList res_list, + unsigned int res_num, + int *idx, + char *buf, + int size, + int *ret_len, + XPointer top, + unsigned long mode) +{ + register int i; + int num = im->private.proto.num_saved_imvalues; + XrmQuark *quark_list = im->private.proto.saved_imvalues; + XIMResourceList res; + XPointer value; + CARD16 *buf_s; + int len; + int min_len = sizeof(CARD16) /* sizeof attribute ID */ + + sizeof(INT16); /* sizeof value length */ + + if (!im->private.proto.saved_imvalues) { + *idx = -1; + *ret_len = 0; + return True; + } + + *ret_len = 0; + for (i = *idx; i < num; i++) { + if (!(res = _XimGetResourceListRecByQuark(res_list, + res_num, quark_list[i]))) + continue; + + if (!_XimDecodeLocalIMAttr(res, top, value)) + return False; + + buf_s = (CARD16 *)buf; + if (!(_XimValueToAttribute(res, (XPointer)&buf_s[2], + (size - min_len), value, &len, mode, (XPointer)NULL))) + return False; + + if (len == 0) { + continue; + } else if (len < 0) { + *idx = i; + return True; + } + + buf_s[0] = res->id; /* attribute ID */ + buf_s[1] = len; /* value length */ + XIM_SET_PAD(&buf_s[2], len); /* pad */ + len += min_len; + + buf += len; + *ret_len += len; + size -= len; + } + *idx = -1; + return True; +} +#endif /* XIM_CONNECTABLE */ + +Private Bool +_XimEncodeTopValue( + Xic ic, + XIMResourceList res, + XIMArg *p) +{ + if (res->xrm_name == XrmStringToQuark(XNClientWindow)) { + ic->core.client_window = (Window)p->value; + if (ic->core.focus_window == (Window)0) + ic->core.focus_window = ic->core.client_window; + _XimRegisterFilter(ic); + + } else if (res->xrm_name == XrmStringToQuark(XNFocusWindow)) { + if (ic->core.client_window) { + _XimUnregisterFilter(ic); + ic->core.focus_window = (Window)p->value; + _XimRegisterFilter(ic); + } else /* client_window not yet */ + ic->core.focus_window = (Window)p->value; + } + return True; +} + +Private Bool +_XimEncodePreeditValue( + Xic ic, + XIMResourceList res, + XIMArg *p) +{ + if (res->xrm_name == XrmStringToQuark(XNStdColormap)) { + XStandardColormap *colormap_ret; + int count; + + if (!(XGetRGBColormaps(ic->core.im->core.display, + ic->core.focus_window, &colormap_ret, + &count, (Atom)p->value))) + return False; + + } else if (res->xrm_name == XrmStringToQuark(XNFontSet)) { + int list_ret; + XFontStruct **struct_list; + char **name_list; + char *tmp; + int len; + register int i; + + if (!p->value) + return False; + + if (ic->private.proto.preedit_font) + Xfree(ic->private.proto.preedit_font); + + list_ret = XFontsOfFontSet((XFontSet)p->value, + &struct_list, &name_list); + for (i = 0, len = 0; i < list_ret; i++) { + len += (strlen(name_list[i]) + sizeof(char)); + } + if (!(tmp = Xmalloc(len + 1))) { + ic->private.proto.preedit_font = NULL; + return False; + } + + tmp[0] = '\0'; + for (i = 0; i < list_ret; i++) { + strcat(tmp, name_list[i]); + strcat(tmp, ","); + } + tmp[len - 1] = 0; + ic->private.proto.preedit_font = tmp; + ic->private.proto.preedit_font_length = len - 1; + } + return True; +} + +Private Bool +_XimEncodeStatusValue( + Xic ic, + XIMResourceList res, + XIMArg *p) +{ + if (res->xrm_name == XrmStringToQuark(XNStdColormap)) { + XStandardColormap *colormap_ret; + int count; + + if (!(XGetRGBColormaps(ic->core.im->core.display, + ic->core.focus_window, &colormap_ret, + &count, (Atom)p->value))) + return False; + + } else if (res->xrm_name == XrmStringToQuark(XNFontSet)) { + int list_ret; + XFontStruct **struct_list; + char **name_list; + char *tmp; + int len; + register int i; + + if (!p->value) + return False; + + if (ic->private.proto.status_font) + Xfree(ic->private.proto.status_font); + + list_ret = XFontsOfFontSet((XFontSet)p->value, + &struct_list, &name_list); + for (i = 0, len = 0; i < list_ret; i++) { + len += (strlen(name_list[i]) + sizeof(char)); + } + if (!(tmp = Xmalloc(len+1))) { + ic->private.proto.status_font = NULL; + return False; + } + + tmp[0] = '\0'; + for(i = 0; i < list_ret; i++) { + strcat(tmp, name_list[i]); + strcat(tmp, ","); + } + tmp[len - 1] = 0; + ic->private.proto.status_font = tmp; + ic->private.proto.status_font_length = len - 1; + } + return True; +} + +Private Bool +_XimSetInnerICAttributes( + Xic ic, + XPointer top, + XIMArg *arg, + unsigned long mode) +{ + XIMResourceList res; + int check; + + if (!(res = _XimGetResourceListRec(ic->private.proto.ic_inner_resources, + ic->private.proto.ic_num_inner_resources, arg->name))) + return False; + + check = _XimCheckICMode(res, mode); + if(check == XIM_CHECK_INVALID) + return True; + else if(check == XIM_CHECK_ERROR) + return False; + + return _XimEncodeLocalICAttr(ic, res, top, arg, mode); +} + +Public char * +_XimEncodeICATTRIBUTE( + Xic ic, + XIMResourceList res_list, + unsigned int res_num, + XIMArg *arg, + XIMArg **arg_ret, + char *buf, + int size, + int *ret_len, + XPointer top, + BITMASK32 *flag, + unsigned long mode) +{ + register XIMArg *p; + XIMResourceList res; + int check; + CARD16 *buf_s; + int len; + int min_len = sizeof(CARD16) /* sizeof attribute ID */ + + sizeof(INT16); /* sizeof value length */ + XrmQuark pre_quark; + XrmQuark sts_quark; + char *name; + + pre_quark = XrmStringToQuark(XNPreeditAttributes); + sts_quark = XrmStringToQuark(XNStatusAttributes); + + *ret_len = 0; + for (p = arg; p && p->name; p++) { + buf_s = (CARD16 *)buf; + if (!(res = _XimGetResourceListRec(res_list, res_num, p->name))) { + if (_XimSetInnerICAttributes(ic, top, p, mode)) + continue; + return p->name; + } + + check = _XimCheckICMode(res, mode); + if (check == XIM_CHECK_INVALID) + continue; + else if (check == XIM_CHECK_ERROR) + return p->name; + + if (mode & XIM_PREEDIT_ATTR) { + if (!(_XimEncodePreeditValue(ic, res, p))) + return p->name; + } else if (mode & XIM_STATUS_ATTR) { + if (!(_XimEncodeStatusValue(ic, res, p))) + return p->name; + } else { + if (!(_XimEncodeTopValue(ic, res, p))) + return p->name; + } + + if (res->resource_size == XimType_NEST) { + XimDefICValues *ic_attr = (XimDefICValues *)top; + + if (res->xrm_name == pre_quark) { + XIMArg *arg_rt; + if ((name = _XimEncodeICATTRIBUTE(ic, res_list, res_num, + (XIMArg *)p->value, &arg_rt, + (char *)&buf_s[2], (size - min_len), + &len, (XPointer)&ic_attr->preedit_attr, flag, + (mode | XIM_PREEDIT_ATTR)))) { + return name; + } + + } else if (res->xrm_name == sts_quark) { + XIMArg *arg_rt; + if ((name = _XimEncodeICATTRIBUTE(ic, res_list, res_num, + (XIMArg *)p->value, &arg_rt, + (char *)&buf_s[2], (size - min_len), + &len, (XPointer)&ic_attr->status_attr, flag, + (mode | XIM_STATUS_ATTR)))) { + return name; + } + } + } else { +#ifdef EXT_MOVE + if (flag) + *flag |= _XimExtenArgCheck(p); +#endif + if (!(_XimEncodeLocalICAttr(ic, res, top, p, mode))) + return p->name; + + if (!(_XimValueToAttribute(res, (XPointer)&buf_s[2], + (size - min_len), p->value, + &len, mode, (XPointer)ic))) + return p->name; + } + + if (len == 0) { + continue; + } else if (len < 0) { + *arg_ret = p; + return (char *)NULL; + } + + buf_s[0] = res->id; /* attribute ID */ + buf_s[1] = len; /* value length */ + XIM_SET_PAD(&buf_s[2], len); /* pad */ + len += min_len; + + buf += len; + *ret_len += len; + size -= len; + } + *arg_ret = (XIMArg *)NULL; + return (char *)NULL; +} + +#ifdef XIM_CONNECTABLE +Private Bool +_XimEncodeSavedPreeditValue( + Xic ic, + XIMResourceList res, + XPointer value) +{ + int list_ret; + XFontStruct **struct_list; + char **name_list; + char *tmp; + int len; + register int i; + + if (res->xrm_name == XrmStringToQuark(XNFontSet)) { + if (!value) + return False; + + if (ic->private.proto.preedit_font) + Xfree(ic->private.proto.preedit_font); + + list_ret = XFontsOfFontSet((XFontSet)value, + &struct_list, &name_list); + for(i = 0, len = 0; i < list_ret; i++) { + len += (strlen(name_list[i]) + sizeof(char)); + } + if(!(tmp = Xmalloc(len + 1))) { + ic->private.proto.preedit_font = NULL; + return False; + } + + tmp[0] = '\0'; + for(i = 0; i < list_ret; i++) { + strcat(tmp, name_list[i]); + strcat(tmp, ","); + } + tmp[len - 1] = 0; + ic->private.proto.preedit_font = tmp; + ic->private.proto.preedit_font_length = len - 1; + } + return True; +} + +Private Bool +_XimEncodeSavedStatusValue( + Xic ic, + XIMResourceList res, + XPointer value) +{ + int list_ret; + XFontStruct **struct_list; + char **name_list; + char *tmp; + int len; + register int i; + + if (res->xrm_name == XrmStringToQuark(XNFontSet)) { + if (!value) + return False; + + if (ic->private.proto.status_font) + Xfree(ic->private.proto.status_font); + + list_ret = XFontsOfFontSet((XFontSet)value, + &struct_list, &name_list); + for(i = 0, len = 0; i < list_ret; i++) { + len += (strlen(name_list[i]) + sizeof(char)); + } + if(!(tmp = Xmalloc(len + 1))) { + ic->private.proto.status_font = NULL; + return False; + } + + tmp[0] = '\0'; + for(i = 0; i < list_ret; i++) { + strcat(tmp, name_list[i]); + strcat(tmp, ","); + } + tmp[len - 1] = 0; + ic->private.proto.status_font = tmp; + ic->private.proto.status_font_length = len - 1; + } + return True; +} + +Public Bool +_XimEncodeSavedICATTRIBUTE( + Xic ic, + XIMResourceList res_list, + unsigned int res_num, + int *idx, + char *buf, + int size, + int *ret_len, + XPointer top, + unsigned long mode) +{ + int i; + int num = ic->private.proto.num_saved_icvalues; + XrmQuark *quark_list = ic->private.proto.saved_icvalues; + XIMResourceList res; + XPointer value; + CARD16 *buf_s; + int len; + int min_len = sizeof(CARD16) /* sizeof attribute ID */ + + sizeof(INT16); /* sizeof value length */ + XrmQuark pre_quark; + XrmQuark sts_quark; + XrmQuark separator; + + if (!ic->private.proto.saved_icvalues) { + *idx = -1; + *ret_len = 0; + return True; + } + + pre_quark = XrmStringToQuark(XNPreeditAttributes); + sts_quark = XrmStringToQuark(XNStatusAttributes); + separator = XrmStringToQuark(XNSeparatorofNestedList); + + *ret_len = 0; + for (i = *idx; i < num; i++) { + if (quark_list[i] == separator) { + *idx = i; + return True; + } + + if (!(res = _XimGetResourceListRecByQuark(res_list, + res_num, quark_list[i]))) + continue; + + if (!_XimDecodeLocalICAttr(res, top,(XPointer)&value, mode)) + return False; + + if (mode & XIM_PREEDIT_ATTR) { + if (!(_XimEncodeSavedPreeditValue(ic, res, value))) { + return False; + } + } else if (mode & XIM_STATUS_ATTR) { + if (!(_XimEncodeSavedStatusValue(ic, res, value))) { + return False; + } + } + + buf_s = (CARD16 *)buf; + if (res->resource_size == XimType_NEST) { + XimDefICValues *ic_attr = (XimDefICValues *)top; + + i++; + if (res->xrm_name == pre_quark) { + if (!_XimEncodeSavedICATTRIBUTE(ic, res_list, res_num, + &i, (char *)&buf_s[2], (size - min_len), + &len, (XPointer)&ic_attr->preedit_attr, + (mode | XIM_PREEDIT_ATTR))) { + return False; + } + + } else if (res->xrm_name == sts_quark) { + if (!_XimEncodeSavedICATTRIBUTE(ic, res_list, res_num, + &i, (char *)&buf_s[2], (size - min_len), + &len, (XPointer)&ic_attr->status_attr, + (mode | XIM_STATUS_ATTR))) { + return False; + } + } + } else { + if (!(_XimValueToAttribute(res, (XPointer)&buf_s[2], + (size - min_len), value, + &len, mode, (XPointer)ic))) { + return False; + } + } + + if (len == 0) { + continue; + } else if (len < 0) { + if (quark_list[i] == separator) + i++; + *idx = i; + return True; + } + + buf_s[0] = res->id; /* attribute ID */ + buf_s[1] = len; /* value length */ + XIM_SET_PAD(&buf_s[2], len); /* pad */ + len += min_len; + + buf += len; + *ret_len += len; + size -= len; + } + *idx = -1; + return True; +} +#endif /* XIM_CONNECTABLE */ + +Private unsigned int +_XimCountNumberOfAttr( + INT16 total, + CARD16 *attr, + int *names_len) +{ + unsigned int n; + INT16 len; + INT16 min_len = sizeof(CARD16) /* sizeof attrinute ID */ + + sizeof(CARD16) /* sizeof type of value */ + + sizeof(INT16); /* sizeof length of attribute */ + + n = 0; + *names_len = 0; + while (total > min_len) { + len = attr[2]; + *names_len += (len + 1); + len += (min_len + XIM_PAD(len + 2)); + total -= len; + attr = (CARD16 *)((char *)attr + len); + n++; + } + return n; +} + +Public Bool +_XimGetAttributeID( + Xim im, + CARD16 *buf) +{ + unsigned int n; + XIMResourceList res; + int res_len; + char *names; + int names_len; + XPointer tmp; + XIMValuesList *values_list; + char **values; + int values_len; + register int i; + INT16 len; + INT16 min_len = sizeof(CARD16) /* sizeof attrinute ID */ + + sizeof(CARD16) /* sizeof type of value */ + + sizeof(INT16); /* sizeof length of attr */ + /* + * IM attribute ID + */ + + if (!(n = _XimCountNumberOfAttr(buf[0], &buf[1], &names_len))) + return False; + res_len = sizeof(XIMResource) * n; + + if (!(res = (XIMResourceList)Xmalloc(res_len))) + return False; + bzero((char *)res, res_len); + + values_len = sizeof(XIMValuesList) + (sizeof(char **) * n) + names_len; + if (!(tmp = (XPointer)Xmalloc(values_len))) + return False; + bzero(tmp, values_len); + + values_list = (XIMValuesList *)tmp; + values = (char **)((char *)tmp + sizeof(XIMValuesList)); + names = (char *)((char *)values + (sizeof(char **) * n)); + + values_list->count_values = n; + values_list->supported_values = values; + + buf++; + for (i = 0; i < n; i++) { + len = buf[2]; + (void)memcpy(names, (char *)&buf[3], len); + values[i] = names; + names[len] = '\0'; + res[i].resource_name = names; + res[i].resource_size = buf[1]; + res[i].id = buf[0]; + names += (len + 1); + len += (min_len + XIM_PAD(len + 2)); + buf = (CARD16 *)((char *)buf + len); + } + _XIMCompileResourceList(res, n); + + if (im->core.im_resources) + Xfree(im->core.im_resources); + if (im->core.im_values_list) + Xfree(im->core.im_values_list); + im->core.im_resources = res; + im->core.im_num_resources = n; + im->core.im_values_list = values_list; + + /* + * IC attribute ID + */ + + if (!(n = _XimCountNumberOfAttr(buf[0], &buf[2], &names_len))) + return False; + res_len = sizeof(XIMResource) * n; + + if (!(res = (XIMResourceList)Xmalloc(res_len))) + return False; + bzero((char *)res, res_len); + + values_len = sizeof(XIMValuesList) + (sizeof(char **) * n) + names_len; + if (!(tmp = (XPointer)Xmalloc(values_len))) + return False; + bzero(tmp, values_len); + + values_list = (XIMValuesList *)tmp; + values = (char **)((char *)tmp + sizeof(XIMValuesList)); + names = (char *)((char *)values + (sizeof(char **) * n)); + + values_list->count_values = n; + values_list->supported_values = values; + + buf += 2; + for (i = 0; i < n; i++) { + len = buf[2]; + (void)memcpy(names, (char *)&buf[3], len); + values[i] = names; + names[len] = '\0'; + res[i].resource_name = names; + res[i].resource_size = buf[1]; + res[i].id = buf[0]; + names += (len + 1); + len += (min_len + XIM_PAD(len + 2)); + buf = (CARD16 *)((char *)buf + len); + } + _XIMCompileResourceList(res, n); + + if (im->core.ic_resources) + Xfree(im->core.ic_resources); + if (im->core.ic_values_list) + Xfree(im->core.ic_values_list); + im->core.ic_resources = res; + im->core.ic_num_resources = n; + im->core.ic_values_list = values_list; + + return True; +} -- cgit v1.2.3