/* called from GetICValueMessageProc */
void _Xi18nGetIC (XIMS ims, IMProtocol *call_data, unsigned char *p)
{
Xi18n i18n_core = ims->protocol;
FrameMgr fm;
FmStatus status;
extern XimFrameRec get_ic_values_fr[];
extern XimFrameRec get_ic_values_reply_fr[];
CARD16 byte_length;
register int total_size;
unsigned char *reply = NULL;
XICAttribute *preedit_ret = NULL;
XICAttribute *status_ret = NULL;
register int i;
register int number;
int iter_count;
CARD16 *attrID_list;
XICAttribute pre_attr[IC_SIZE];
XICAttribute sts_attr[IC_SIZE];
XICAttribute ic_attr[IC_SIZE];
CARD16 pre_count = 0;
CARD16 sts_count = 0;
CARD16 ic_count = 0;
IMChangeICStruct *getic = (IMChangeICStruct *) &call_data->changeic;
CARD16 connect_id = call_data->any.connect_id;
CARD16 input_method_ID;
memset (pre_attr, 0, sizeof (XICAttribute)*IC_SIZE);
memset (sts_attr, 0, sizeof (XICAttribute)*IC_SIZE);
memset (ic_attr, 0, sizeof (XICAttribute)*IC_SIZE);
fm = FrameMgrInit (get_ic_values_fr,
(char *) p,
_Xi18nNeedSwap (i18n_core, connect_id));
/* get data */
FrameMgrGetToken (fm, input_method_ID);
FrameMgrGetToken (fm, getic->icid);
FrameMgrGetToken (fm, byte_length);
attrID_list = (CARD16 *) malloc (sizeof (CARD16)*IC_SIZE); /* bogus */
memset (attrID_list, 0, sizeof (CARD16)*IC_SIZE);
number = 0;
while (FrameMgrIsIterLoopEnd (fm, &status) == False)
FrameMgrGetToken (fm, attrID_list[number++]);
/*endwhile*/
FrameMgrFree (fm);
i = 0;
while (i < number)
{
int read_number;
if (IsNestedList (i18n_core, attrID_list[i]))
{
if (attrID_list[i] == i18n_core->address.preeditAttr_id)
{
read_number = GetICValue (i18n_core,
&pre_attr[pre_count],
&attrID_list[i],
number);
i += read_number + 1;
pre_count += read_number;
}
else if (attrID_list[i] == i18n_core->address.statusAttr_id)
{
read_number = GetICValue (i18n_core,
&sts_attr[sts_count],
&attrID_list[i],
number);
i += read_number + 1;
sts_count += read_number;
}
else
{
/* another nested list.. possible? */
}
/*endif*/
}
else
{
read_number = GetICValue (i18n_core,
&ic_attr[ic_count],
&attrID_list[i],
number);
i += read_number;
ic_count += read_number;
}
/*endif*/
}
/*endwhile*/
getic->preedit_attr_num = pre_count;
getic->status_attr_num = sts_count;
getic->ic_attr_num = ic_count;
getic->preedit_attr = pre_attr;
getic->status_attr = sts_attr;
getic->ic_attr = ic_attr;
if (i18n_core->address.improto)
{
if (!(i18n_core->address.improto (ims, call_data)))
return;
/*endif*/
if (_Xi18nNeedSwap (i18n_core, connect_id))
SwapAttributes(getic->ic_attr, getic->ic_attr_num);
}
/*endif*/
iter_count = getic->ic_attr_num;
preedit_ret = CreateNestedList (i18n_core->address.preeditAttr_id,
getic->preedit_attr,
getic->preedit_attr_num,
_Xi18nNeedSwap (i18n_core, connect_id));
if (preedit_ret)
iter_count++;
/*endif*/
status_ret = CreateNestedList (i18n_core->address.statusAttr_id,
getic->status_attr,
getic->status_attr_num,
_Xi18nNeedSwap (i18n_core, connect_id));
if (status_ret)
iter_count++;
/*endif*/
fm = FrameMgrInit (get_ic_values_reply_fr,
NULL,
_Xi18nNeedSwap (i18n_core, connect_id));
/* set iteration count for list of ic_attribute */
FrameMgrSetIterCount (fm, iter_count);
/* set length of BARRAY item in xicattribute_fr */
for (i = 0; i < (int) getic->ic_attr_num; i++)
FrameMgrSetSize (fm, ic_attr[i].value_length);
/*endfor*/
if (preedit_ret)
FrameMgrSetSize (fm, preedit_ret->value_length);
/*endif*/
if (status_ret)
FrameMgrSetSize (fm, status_ret->value_length);
/*endif*/
total_size = FrameMgrGetTotalSize (fm);
reply = (unsigned char *) malloc (total_size);
if (reply == NULL)
{
_Xi18nSendMessage (ims, connect_id, XIM_ERROR, 0, 0, 0);
return;
}
/*endif*/
memset (reply, 0, total_size);
FrameMgrSetBuffer (fm, reply);
FrameMgrPutToken (fm, input_method_ID);
FrameMgrPutToken (fm, getic->icid);
for (i = 0; i < (int) getic->ic_attr_num; i++)
{
FrameMgrPutToken (fm, ic_attr[i].attribute_id);
FrameMgrPutToken (fm, ic_attr[i].value_length);
FrameMgrPutToken (fm, ic_attr[i].value);
}
/*endfor*/
if (preedit_ret)
{
FrameMgrPutToken (fm, preedit_ret->attribute_id);
FrameMgrPutToken (fm, preedit_ret->value_length);
FrameMgrPutToken (fm, preedit_ret->value);
}
/*endif*/
if (status_ret)
{
FrameMgrPutToken (fm, status_ret->attribute_id);
FrameMgrPutToken (fm, status_ret->value_length);
FrameMgrPutToken (fm, status_ret->value);
}
/*endif*/
_Xi18nSendMessage (ims,
connect_id,
XIM_GET_IC_VALUES_REPLY,
0,
reply,
total_size);
XFree (reply);
XFree (attrID_list);
for (i = 0; i < (int) getic->ic_attr_num; i++)
{
if (getic->ic_attr[i].name)
XFree (getic->ic_attr[i].name);
/*endif*/
if (getic->ic_attr[i].value)
XFree (getic->ic_attr[i].value);
/*endif*/
}
/*endfor*/
for (i = 0; i < (int) getic->preedit_attr_num; i++)
{
if (getic->preedit_attr[i].name)
XFree (getic->preedit_attr[i].name);
/*endif*/
if (getic->preedit_attr[i].value)
XFree (getic->preedit_attr[i].value);
/*endif*/
}
/*endfor*/
for (i = 0; i < (int) getic->status_attr_num; i++)
{
if (getic->status_attr[i].name)
XFree (getic->status_attr[i].name);
/*endif*/
if (getic->status_attr[i].value)
XFree (getic->status_attr[i].value);
/*endif*/
}
/*endfor*/
if (preedit_ret)
{
XFree (preedit_ret->value);
XFree (preedit_ret);
}
/*endif*/
if (status_ret)
{
XFree (status_ret->value);
XFree (status_ret);
}
/*endif*/
FrameMgrFree (fm);
}
void _Xi18nSendTriggerKey(XIMS ims, CARD16 connect_id)
{
Xi18n i18n_core = ims->protocol;
FrameMgr fm;
extern XimFrameRec register_triggerkeys_fr[];
XIMTriggerKey *on_keys = i18n_core->address.on_keys.keylist;
XIMTriggerKey *off_keys = i18n_core->address.off_keys.keylist;
int on_key_num = i18n_core->address.on_keys.count_keys;
int off_key_num = i18n_core->address.off_keys.count_keys;
unsigned char *reply = NULL;
register int i, total_size;
CARD16 im_id;
if (on_key_num == 0 && off_key_num == 0)
return;
/*endif*/
fm = FrameMgrInit(register_triggerkeys_fr,
NULL,
_Xi18nNeedSwap(i18n_core, connect_id));
/* set iteration count for on-keys list */
FrameMgrSetIterCount(fm, on_key_num);
/* set iteration count for off-keys list */
FrameMgrSetIterCount(fm, off_key_num);
/* get total_size */
total_size = FrameMgrGetTotalSize(fm);
reply = (unsigned char *) malloc(total_size);
if (!reply)
return;
/*endif*/
memset(reply, 0, total_size);
FrameMgrSetBuffer(fm, reply);
/* Right now XIM_OPEN_REPLY hasn't been sent to this new client, so
the input-method-id is still invalid, and should be set to zero...
Reter to $(XC)/lib/X11/imDefLkup.c:_XimRegisterTriggerKeysCallback
*/
im_id = 0;
FrameMgrPutToken(fm, im_id); /* input-method-id */
for (i = 0; i < on_key_num; i++) {
FrameMgrPutToken(fm, on_keys[i].keysym);
FrameMgrPutToken(fm, on_keys[i].modifier);
FrameMgrPutToken(fm, on_keys[i].modifier_mask);
}
/*endfor*/
for (i = 0; i < off_key_num; i++) {
FrameMgrPutToken(fm, off_keys[i].keysym);
FrameMgrPutToken(fm, off_keys[i].modifier);
FrameMgrPutToken(fm, off_keys[i].modifier_mask);
}
/*endfor*/
_Xi18nSendMessage(ims,
connect_id,
XIM_REGISTER_TRIGGERKEYS,
0,
reply,
total_size);
FrameMgrFree(fm);
XFree(reply);
}
