xlocalim.c

早期freebsd实现

Bool
_XipLocalBackEndFilter(display, window, ev, client_data)
    Display *display;
    Window window;
    XEvent *ev;
    XPointer client_data;
{
    register XipLocalIC	ic = (XipLocalIC)client_data;
    XipLocalCvt		*xcvt = ic->xcvt;
    KeySym keysym;
    int keycode;
    int	i, c;		/* work */
    char str[256];
    XEvent dummy_ev;

    if (xcvt->cnt == 0)
	return(False);

    if (ev->xkey.keycode == 0) {
	if (_XipTypeOfNextICQueue((XipIC)ic) == XIM_KEYSYM){
	    if ((keycode = XKeysymToKeycode(display,
			    _XipKeySymOfNextICQueue((XipIC)ic))) != 0
		&& _XipStringOfNextICQueue((XipIC)ic) == NULL){
		ev->xkey.state = _XipStateOfNextICQueue((XipIC)ic);
		ev->xkey.keycode = keycode;
		_XipFreeNextICQueue((XipIC)ic);
	    }
	}
	return(False);
    }

    if (ic->out) ic->out = NULL;
    
    (void)XLookupString(ev, str, 256, &keysym, NULL);

    if (keysym == NoSymbol/* || nbytes < 1 */) {
	return(True);
    }
    if (is_nofilter(xcvt, keysym)) return(False);
    if (keysym == xcvt->bs) {
	if (xcvt->buf_cnt == 0) {
	    return(False);
	}
	xcvt->buf[xcvt->buf_cnt - 1].keysym = xcvt->buf[xcvt->buf_cnt].keysym;
	xcvt->buf[xcvt->buf_cnt - 1].state = xcvt->buf[xcvt->buf_cnt].state;
	_XipLocalClearCvt(xcvt);
	if (--xcvt->buf_cnt > 0) {
	    key_check(xcvt);
	}
	return(True);
    }
    if (xcvt->buf_cnt == 0) {
	_XipLocalClearCvt(xcvt);
    }
    xcvt->buf[xcvt->buf_cnt].keysym = keysym;
    xcvt->buf[xcvt->buf_cnt].state = ev->xkey.state;
    xcvt->buf[++xcvt->buf_cnt].keysym = XK_VoidSymbol;
    bcopy((char *)ev, (char *)&dummy_ev, sizeof(XEvent));
    dummy_ev.type = KeyPress;
    dummy_ev.xkey.state = 0;
    dummy_ev.xkey.keycode = 0;

    if (xcvt->off == True) {
	if ((c = off_key_check(xcvt)) == 0) {
	    xcvt->buf_cnt = 0;
	    (*xcvt->off_tbl.to.func)(xcvt);
	    _XipLocalClearCvt(xcvt);
	    return(True);
	}
    } else {
	c = key_check(xcvt);
    }
    switch (c) {
    case -1: /* Event was filtered */
	return (True);
    case -2: /* No match */
	for (i = 0; i < xcvt->buf_cnt; i++) {
	     if (_XipPutICQueue(ic, XIM_KEYSYM, 0, xcvt->buf[i].keysym,
				xcvt->buf[i].state, 0, NULL) < 0)
	       return(False);
	}
	ev->xkey.state = 0;
	ev->xkey.keycode = 0;
	if ((keycode = XKeysymToKeycode(display,
				_XipKeySymOfNextICQueue((XipIC)ic))) != 0
	    && _XipStringOfNextICQueue((XipIC)ic) == NULL) {
	    ev->xkey.state = _XipStateOfNextICQueue((XipIC)ic);
	    ev->xkey.keycode = keycode;
	    _XipFreeNextICQueue((XipIC)ic);
	}
	for (i = 1; i < xcvt->buf_cnt; i++) {
	    XPutBackEvent(display, &dummy_ev);
	}
	xcvt->buf_cnt = 0;
	_XipLocalClearCvt(xcvt);
	return (False);
    default: /* matched */
        xcvt->buf_cnt = 0;
	if (xcvt->tbl[c].com == True) {
	    if ((*xcvt->tbl[c].to.func)(xcvt) == True) {
		_XipLocalClearCvt(xcvt);
		return(True);
	    }
	}
	for (i = 0; xcvt->tbl[c].to.tokey[i].keysym != XK_VoidSymbol; i++) {
	     if (_XipPutICQueue(ic, XIM_KEYSYM, 0,
				xcvt->tbl[c].to.tokey[i].keysym,
				xcvt->tbl[c].to.tokey[i].state, 1,
				xcvt->tbl[c].to.tokey[i].str) < 0)
	       return(False);
	}
	ev->xkey.state = 0;
	ev->xkey.keycode = 0;
	if ((keycode = XKeysymToKeycode(display,
				_XipKeySymOfNextICQueue((XipIC)ic))) != 0
	    && _XipStringOfNextICQueue((XipIC)ic) == NULL) {
	    ev->xkey.state = _XipStateOfNextICQueue((XipIC)ic);
	    ev->xkey.keycode = keycode;
	    _XipFreeNextICQueue((XipIC)ic);
	}
	for (i = 1; xcvt->tbl[c].to.tokey[i].keysym != XK_VoidSymbol; i++) {
	    XPutBackEvent(display, &dummy_ev);
	}
	xcvt->buf_cnt = 0;
	_XipLocalClearCvt(xcvt);
	return(False);
    }
}

/*
 * Free the input context.
 */
void
_XipLocalDestroyIC(supic)
    XIC supic;
{
    XipLocalIC ic = (XipLocalIC)supic;
    XipLocalIM im = (XipLocalIM)ic->core.im;

    _XUnregisterFilter(im->core.display, ic->core.focus_window,
		       ic->prototype_filter, (XPointer)ic);

#ifdef	XML
    if (ic->xlc_num > 0) {
	int i;

	for (i = 0; i < ic->xlc_num; i++) {
	    _XlcFreeLocale(ic->mb_temp[i]);
	    _XlcFreeLocale(ic->wc_temp[i]);
	    _XipLocalFreeCvt(ic->xcvt);
	}
    }
    if (ic->values.using_language) Xfree(ic->values.using_language);
#endif	/* XML */
}

static RConst XICMethodsRec ic_methods = {
    _XipLocalDestroyIC,
    _XipLocalSetICFocus,
    _XipLocalUnsetICFocus,
    _XipLocalSetICValues,
    _XipLocalGetICValues,
    _XipLocalmbResetIC,
    _XipLocalwcResetIC,
    _XipmbLookupString,
    _XipwcLookupString
};

/*
 * Create an input context within the input method, 
 * and return a pointer the input context ti the caller.
 */
XIC
_XipLocalCreateIC(supim, args)
    XIM supim;
    XIMArg *args;
{
    XipLocalIM		im = (XipLocalIM)supim;
    XipLocalIC		ic;
    unsigned long	mask = 0L;
#ifdef	XML
    char		**nls_list, **l;
    XLocale		xlc;
#endif	/* XML */

    if ((ic = (XipLocalIC)Xcalloc(1, sizeof(XipLocalICRec))) == NULL) {
	return(NULL);
    }

    ic->methods = (XICMethods) &ic_methods;
    ic->prototype_filter = _XipLocalBackEndFilter;
    ic->core.im = supim;
    (void)_XipICSetValues(ic, args, &mask);

#ifdef	XML
    if (im->xlc != NULL) {
#endif	/* XML */
	ic->mb = _XlcDupLocale(im->xlc);
	ic->wc = _XlcDupLocale(im->xlc);
	ic->xcvt = _XipLocalDupCvt(im->xcvt);
#ifdef	XML
	ic->xlc_num = 0;
	ic->mb_temp = NULL;
	ic->wc_temp = NULL;
	ic->xcvt_temp = NULL;
    } else {
	ic->mb = NULL;
	ic->wc = NULL;
	ic->xcvt_temp = NULL;
	ic->xlc_num = 0;
	if ((ic->mb_temp = (XLocale*)Xmalloc(sizeof(XLocale) * 32)) == NULL) {
	    return(NULL);
	}
	if ((ic->wc_temp = (XLocale*)Xmalloc(sizeof(XLocale) * 32)) == NULL) {
	    return(NULL);
	}
	if ((ic->xcvt_temp = (XipLocalCvt**)
	     Xmalloc(sizeof(XipLocalCvt*) * 32)) == NULL) {
	    return(NULL);
	}
	_XlcListLocale(&nls_list);
	for (l = nls_list; *l; l++) {
	    xlc = _XlcMakeLocale(*l);
	    if (!xlc)
		continue;
	    if ((ic->xcvt_temp[ic->xlc_num] = _XipLocalCvtSetUp(xlc)) == NULL){
		_XlcFreeLocale(xlc);
	        continue;
	    }
	    ic->mb_temp[ic->xlc_num] = xlc;
	    ic->wc_temp[ic->xlc_num] = _XlcDupLocale(xlc);
	    ic->xlc_num++;
	}
	Xfree((char *)nls_list);
	ic->mb = ic->mb_temp[0];
	ic->wc = ic->wc_temp[0];
	ic->xcvt = ic->xcvt_temp[0];
    }
#endif /* XML */
    return((XIC)ic);
}

/*
 * Reset the input context. 
 */
wchar_t *
_XipLocalwcResetIC(supic)
    XIC supic;		/* specified the input context to reset*/
{
    register XipLocalIC	ic = (XipLocalIC)supic;

    ic->xcvt->buf_cnt = 0;
    _XipLocalClearCvt(ic->xcvt);
    return((wchar_t *)NULL);
}

char *
_XipLocalmbResetIC(supic)
    XIC supic;		/* specified the input context to reset*/
{
    register XipLocalIC	ic = (XipLocalIC)supic;

    ic->xcvt->buf_cnt = 0;
    _XipLocalClearCvt(ic->xcvt);
    return(NULL);
}

/*
 * Query Input Method.
 */
static char *
_IMGetValues(im, args)
    register XipLocalIM im;
    register XIMArg *args;
{
    register XIMArg		*arg;
    register int		i;
    register XrmName		Name;
    register XIMrmResourceList	xrmres;
    unsigned int		num_resources = im->num_resources;
    XrmQuark			query_input =
				     XrmPermStringToQuark(XNQueryInputStyle);

    for (arg = args; arg->name && *(arg->name); arg++) {
	Name = XrmStringToName(arg->name);
	for (xrmres = im->resources, i = 0;
	     i < num_resources; i++, xrmres++) {
	    if (Name == xrmres->xrm_name) {
		if (Name == query_input) {
		    char *p;
		    XIMStyles *styles;
		    int size = sizeof(XIMStyle)
			       * im->values.input_styles.count_styles;
		    int all_size = sizeof(XIMStyles) + size;
		    if ((p = Xmalloc((unsigned)all_size)) == NULL) {
			continue;
		    }
		    styles = (XIMStyles *)p;
		    styles->count_styles = im->values.input_styles.count_styles;
		    styles->supported_styles =
					(XIMStyle *)(p + sizeof(XIMStyles));
		    bcopy((char *)im->values.input_styles.supported_styles,
			  (char *)styles->supported_styles, size);
		    bcopy((char *)&styles, (char *)arg->value,
			  sizeof(XIMStyles *));
		} else {
		    (void) _XCopyToArg((char *)im - xrmres->xrm_offset - 1,
				       &arg->value,
				       (unsigned int)xrmres->xrm_size);
		}
		break;
	    }
	}
	if (i >= num_resources) return(arg->name);
    }
    return NULL;
}

char *
_XipLocalGetIMValues(supim, args)
    XIM supim;
    XIMArg *args;
{
    XipLocalIM im = (XipLocalIM)supim;

    return(_IMGetValues(im, args));
}

/*
 * Require the input manager to focus the focus window attached to the ic
 * argument.
 */
void
_XipLocalSetICFocus(supic)
    XIC supic;
{
    XipLocalIC		ic = (XipLocalIC)supic;
    XipLocalIM		im = ipLocalIMofIC(ic);

    _XRegisterFilterByMask(im->core.display, ic->core.focus_window,
			   KeyPressMask, ic->prototype_filter, (XPointer)ic);
}

/*
 * Require the input manager to unfocus the focus window attached to the ic
 * argument.
 */
void
_XipLocalUnsetICFocus(supic)
    XIC supic;
{
    XipLocalIC		ic = (XipLocalIC)supic;
    XipLocalIM		im = ipLocalIMofIC(ic);
    _XUnregisterFilter(im->core.display, ic->core.focus_window,
		       ic->prototype_filter, (XPointer)ic);
}

char*
_XipLocalGetICValues(supic, args)
    XIC supic;
    XIMArg *args;
{
    XipLocalIC		ic = (XipLocalIC)supic;
    unsigned long	mask = 0L;

    return(_XipICGetValues((XipIC)ic, args, &mask, 0));
}

#ifdef	XML
void
_XipLocalChangeLocale(ic, lc_name)
    XipLocalIC ic;
    char *lc_name;
{
    XLocale xlc;
    int i;

    for (i = 0; i < ic->xlc_num; i++) {
	if ((!strcmp(lc_name, ic->mb_temp[i]->lc_lang)) ||
	    (!strcmp(lc_name, ic->mb_temp[i]->xlc_db->lc_name))) {
	    ic->mb = ic->mb_temp[i];
	    ic->wc = ic->wc_temp[i];
	    ic->xcvt = ic->xcvt_temp[i];
	    return;
	}
    }
    xlc = _XlcMakeLocale(lc_name);
    if (xlc) {
	if ((ic->xcvt = ic->xcvt_temp[ic->xlc_num] = _XipLocalCvtSetUp(xlc))
	    == NULL) {
	    _XlcFreeLocale(xlc);
	    return;
	}
	ic->mb = ic->mb_temp[ic->xlc_num] = xlc;
	ic->wc = ic->wc_temp[ic->xlc_num] = _XlcDupLocale(xlc);
	ic->xlc_num++;
    }
}
#endif	/* XML */

char *
_XipLocalSetICValues(supic, args)
    XIC supic;
    XIMArg *args;
{
    XipLocalIC		ic = (XipLocalIC)supic;
    XipLocalIM		im = ipLocalIMofIC(ic);
    unsigned long	mask = 0L;
    Window		old_focus_window;
    char		*err = NULL;

    old_focus_window = ic->core.focus_window;

    err = _XipICSetValues((XipIC)ic, args, &mask);
    if (err)
	return(err);
    
    if (mask & (1L << ICFocusWindow)) {
	_XUnregisterFilter(im->core.display, old_focus_window,
			   ic->prototype_filter, (XPointer)ic);
	_XRegisterFilterByMask(im->core.display, ic->core.focus_window,
			       KeyPressMask,
			       ic->prototype_filter, (XPointer)ic);
    }
#ifdef	XML
    if (mask & (1L << ICCurrentLanguage)) {
	_XipLocalChangeLocale(ic, ic->values.current_language);
    }
#endif	/* XML */

    return(NULL);
}