usr/src/contrib/X11R5-lib/lib/X/Xsi/XICGetVal.c

/*
 * $XConsortium: XICGetVal.c,v 1.16 91/12/02 17:29:37 rws Exp $
 */

/*
 * Copyright 1990, 1991 by OMRON Corporation
 * Copyright 1991 by the Massachusetts Institute of Technology
 *
 * 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 names of OMRON and MIT not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  OMRON and MIT make no representations
 * about the suitability of this software for any purpose.  It is provided
 * "as is" without express or implied warranty.
 *
 * OMRON AND MIT DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL OMRON OR MIT 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
 * TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 *
 *      Author: Seiji Kuwari    OMRON Corporation
 *                              kuwa@omron.co.jp
 *                              kuwa%omron.co.jp@uunet.uu.net
 */

#include "Xlibint.h"
#include "Xi18nint.h"
#include "XIMlibint.h"
#if NeedVarargsPrototypes
# include <stdarg.h>
# define Va_start(a,b) va_start(a,b)
#else
# include <varargs.h>
# define Va_start(a,b) va_start(a)
#endif

/*
 * Get a attributes of input context depended on the nested argument list.
 */
static char *
_ICGetAttrValues(im, args, attr, mask, offset, mask_only)
    register XipIM im;
    register XIMArg *args;
    ICAttributes *attr;
    unsigned long *mask;
    int offset;
    char mask_only;
{
    register                    XIMArg *arg;
    register int                i;
    register XrmName            Name;
    register XIMrmResourceList  xrmres;
    XPointer                    *location;
    register unsigned int       num_resources = im->core.ic_num_attr_resources;
    XrmQuark                    spot_name =
                                    XrmPermStringToQuark(XNSpotLocation);
    XrmQuark                    area_needed_name =
                                    XrmPermStringToQuark(XNAreaNeeded);
    XrmQuark                    area_name =
                                    XrmPermStringToQuark(XNArea);

    for (arg = args; arg && arg->name && *(arg->name) ; arg++) {
        Name = XrmStringToName(arg->name);
        for (xrmres = im->core.ic_attr_resources, i = 0;
             i < num_resources; i++, xrmres++) {
            if (Name == xrmres->xrm_name) {
                if (!(xrmres->mode & IMResourceRead)) {
                    return(arg->name);
                }
                if (!mask_only) {
                    if (Name == area_needed_name || Name == area_name ||
                                                    Name == spot_name) {
                        location = (XPointer*)arg->value;
                        *location = (XPointer)Xmalloc(xrmres->xrm_size);
                    } else {
                        location = (XPointer *)&arg->value;
                    }
                    (void)_XCopyToArg((char *)attr - xrmres->xrm_offset - 1,
                                       location,
                                       (unsigned int)xrmres->xrm_size);
                }
                if (xrmres->mask >= 0) {
                    *mask |= (1L << (xrmres->mask + offset));
                }
                break;
            }
        }
        if (i >= num_resources) return(arg->name);
    }
    return(NULL);
}

/*
 * Get input context specified by the nested argument list.
 */
char *
_XipICGetValues(ic, args, mask, mask_only)
    register XipIC ic;
    register XIMArg *args;
    unsigned long *mask;
    char mask_only;
{
    XipIM                       im = ipIMofIC(ic);
    register XIMArg             *arg;
    register int                i;
    register XrmName            Name;
    register XIMrmResourceList  xrmres;
    register unsigned int       num_resources = im->core.ic_num_resources;
    char                        *err;
    XrmQuark                    preedit_name =
                                    XrmPermStringToQuark(XNPreeditAttributes);
    XrmQuark                    status_name =
                                    XrmPermStringToQuark(XNStatusAttributes);

    for (arg = args; arg && arg->name && *(arg->name); arg++) {
        Name = XrmStringToName(arg->name);
        for (xrmres = im->core.ic_resources, i = 0;
             i < num_resources; i++, xrmres++) {
            if (Name == xrmres->xrm_name) {
                if (Name == preedit_name) {
                    if ((err = _ICGetAttrValues(im, (XIMArg *)arg->value,
                                                &ic->core.preedit_attr,
                                                mask, 0, mask_only)) != NULL) {
                        return(err);
                    }
                } else if (Name == status_name) {
                    if ((err = _ICGetAttrValues(im, (XIMArg *)arg->value,
                                                &ic->core.status_attr,
                                                mask, StatusOffset,
                                                mask_only)) != NULL) {
                        return(err);
                    }
                } else {
                    if (!(xrmres->mode & IMResourceRead)) {
                        return(arg->name);
                    }
                    if (!mask_only) {
                        (void) _XCopyToArg((char *)ic - xrmres->xrm_offset - 1,
                                           &arg->value,
                                           (unsigned int)xrmres->xrm_size);
                    }
                    if (xrmres->mask >= 0) {
                        *mask |= (1L << (xrmres->mask));
                    }
                }
                break;
            }
        }
        if (i >= num_resources) return(arg->name);
    }
    return(NULL);
}

static int
_ReceiveICAttrValues(im, attr, mask, offset)
    XipIM im;
    register ICAttributes *attr;
    unsigned long mask;
    int offset;
{
    ximICAttributesReq  reply;

    if (_XipReadFromIM(im, (char *)&reply, sz_ximICAttributesReq) < 0)
        return(-1);

    if (mask & (1L << (ICArea + offset))) {
        attr->area.x = reply.area_x;
        attr->area.y = reply.area_y;
        attr->area.width = reply.area_width;
        attr->area.height = reply.area_height;
    }
    if (mask & (1L << (ICAreaNeeded + offset))) {
        attr->area_needed.width = reply.areaneeded_width;
        attr->area_needed.height = reply.areaneeded_height;
    }
    if (mask & (1L << ICSpotLocation + offset)) {
        attr->spot_location.x = reply.spot_x;
        attr->spot_location.y = reply.spot_y;
    }
    if (mask & (1L << (ICColormap + offset))) {
        attr->colormap = reply.colormap;
    }
    if (mask & (1L << (ICStdColormap + offset))) {
        attr->std_colormap = reply.std_colormap;
    }
    if (mask & (1L << (ICForeground + offset))) {
        attr->foreground = reply.foreground;
    }
    if (mask & (1L << (ICBackground + offset))) {
        attr->background = reply.background;
    }
    if (mask & (1L << (ICBackgroundPixmap + offset))) {
        attr->background_pixmap = reply.pixmap;
    }
    if (mask & (1L << (ICLineSpace + offset))) {
        attr->line_space = reply.line_space;
    }
    if (mask & (1L << (ICCursor + offset))) {
        attr->cursor = reply.cursor;
    }
    return(0);
}

Status
_XipReceiveICValues(ic, mask)
    register XipIC ic;
    unsigned long mask;
{
    XipIM im = ipIMofIC(ic);
    register char *p = NULL, *p2 = NULL;
    ximGetICReq req;
    ximGetICReply reply;
    ximICValuesReq ic_req;

    req.reqType = XIM_GetIC;
    req.length = sz_ximGetICReq;
    req.xic = ic->icid;
    req.mask = mask;
    if ((_XipWriteToIM(im, (char *)&req, sz_ximGetICReq) < 0) ||
        (_XipFlushToIM(im) < 0)) {
        return(-1);
    }

    if (_XipReadFromIM(im, (char *)&reply, sz_ximGetICReply) < 0) {
        return(-1);
    }
    if (reply.state != 0) {
        return(-1);
    }
    if (_XipReadFromIM(im, (char *)&ic_req, sz_ximICValuesReq) < 0) {
        return(-1);
    }
    if (ic_req.nbytes > 0) {
        if ((p = Xmalloc((unsigned)(ic_req.nbytes + 1))) == NULL) return(-1);
        if (_XipReadFromIM(im, p, ic_req.nbytes) < 0) {
            return(-1);
        }
        p[ic_req.nbytes] = '\0';
    }
    if (ic_req.nbytes2 > 0) {
        if ((p2 = Xmalloc((unsigned)(ic_req.nbytes2 + 1))) == NULL) return(-1);
        if (_XipReadFromIM(im, p2, ic_req.nbytes2) < 0) {
            return(-1);
        }
        p2[ic_req.nbytes2] = '\0';
    }

    if (mask & (1L << ICInputStyle)) {
        ic->core.input_style = ic_req.input_style;
    }
    if (mask & (1L << ICClientWindow)) {
        ic->core.client_window = ic_req.c_window;
    }
    if (mask & (1L << ICFocusWindow)) {
        ic->core.focus_window = ic_req.focus_window;
    }
    if (mask & (1L << ICFilterEvents)) {
        ic->core.filter_events = ic_req.filter_events;
    }
#ifdef  XML
    if (mask & (1L << ICUsingLanguage)) {
        if (ic->values.using_language) Xfree(ic->values.using_language);
        if (p == NULL) {
            ic->values.using_language = NULL;
        } else {
            ic->values.using_language = p;
        }
    }
    if (mask & (1L << ICCurrentLanguage)) {
        if (ic->values.current_language) Xfree(ic->values.current_language);
        if (p2 == NULL) {
            ic->values.current_language = NULL;
        } else {
            ic->values.current_language = p2;
        }
    }
#else   /* XML */
    if (ic_req.nbytes > 0) Xfree(p);
    if (ic_req.nbytes2 > 0) Xfree(p2);
#endif  /* XML */
    if ((_ReceiveICAttrValues(im, &ic->core.preedit_attr, mask, 0) < 0) ||
        (_ReceiveICAttrValues(im, &ic->core.status_attr, mask, StatusOffset) < 0)) {
        return(-1);
    }
    return(0);
}

char*
_XipGetICValues(supic, args)
    XIC supic;
    XIMArg *args;
{
    XipIC               ic = (XipIC)supic;
    XipIM               im = ipIMofIC(ic);
    unsigned long       mask = 0L;
    char                *err;

    if (im->fd < 0) return(NULL);

    err = _XipICGetValues(ic, args, &mask, 1);
    if (err)
        return err;
    /*
     * Attempt to receive current IC data from the input manager.
     */
    if (!_XipReceiveICValues(ic, mask))
        (void)_XipICGetValues(ic, args, &mask, 0);
    return NULL;
}