home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xim_Rm.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  81KB  |  3,073 lines
  1. /* $TOG: imRm.c /main/11 1997/06/22 18:26:20 kaleb $ */
  2. /******************************************************************
  3.  
  4.       Copyright 1990, 1991, 1992,1993, 1994 by FUJITSU LIMITED
  5.       Copyright 1994                        by Sony Corporation
  6.  
  7. Permission to use, copy, modify, distribute, and sell this software
  8. and its documentation for any purpose is hereby granted without fee,
  9. provided that the above copyright notice appear in all copies and
  10. that both that copyright notice and this permission notice appear
  11. in supporting documentation, and that the name of FUJITSU LIMITED
  12. and Sony Corporation not be used in advertising or publicity
  13. pertaining to distribution of the software without specific,
  14. written prior permission. FUJITSU LIMITED and Sony Corporation make
  15. no representations about the suitability of this software for any
  16. purpose. It is provided "as is" without express or implied warranty.
  17.  
  18. FUJITSU LIMITED AND SONY CORPORATION DISCLAIM ALL WARRANTIES WITH
  19. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  20. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL FUJITSU LIMITED AND
  21. SONY CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  22. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  23. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  24. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  25. PERFORMANCE OF THIS SOFTWARE.
  26.  
  27.   Author: Takashi Fujiwara     FUJITSU LIMITED 
  28.                    fujiwara@a80.tech.yk.fujitsu.co.jp
  29.   Modifier: Makoto Wakamatsu   Sony Corporation
  30.                    makoto@sm.sony.co.jp
  31.  
  32. ******************************************************************/
  33. /* $XFree86: xc/lib/X11/imRm.c,v 3.1.2.5 1998/10/04 13:36:23 hohndel Exp $ */
  34.  
  35. #include <stdio.h>
  36. #include <X11/Xlib.h>
  37. #include "Xlib_private.h"
  38. #include "Xlcint.h"
  39. #include "Ximint.h"
  40. #include "Xresource.h"
  41. #include "snprintf.h"
  42.  
  43. #ifndef    isalnum
  44. #define    isalnum(c)    \
  45.     (('0' <= (c) && (c) <= '9')  || \
  46.      ('A' <= (c) && (c) <= 'Z')  || \
  47.      ('a' <= (c) && (c) <= 'z'))
  48. #endif
  49.  
  50. typedef struct _XimValueOffsetInfo {
  51.     char        *name;
  52.     XrmQuark         quark;
  53.     unsigned int     offset;
  54.     Bool         (*defaults)(
  55. #if NeedNestedPrototypes
  56.     struct _XimValueOffsetInfo *, XPointer, XPointer, unsigned long
  57. #endif
  58.              );
  59.     Bool         (*encode)(
  60. #if NeedNestedPrototypes
  61.     struct _XimValueOffsetInfo *, XPointer, XPointer
  62. #endif
  63.              );
  64.     Bool         (*decode)(
  65. #if NeedNestedPrototypes
  66.     struct _XimValueOffsetInfo *, XPointer, XPointer
  67. #endif
  68.              );
  69. } XimValueOffsetInfoRec, *XimValueOffsetInfo;
  70.  
  71. static void
  72. _XimGetResourceName(im, res_name, res_class, size)
  73.     Xim         im;
  74.     char    *res_name;
  75.     char    *res_class;
  76.     int        size;
  77. {
  78.     if(im->core.res_name == NULL) {
  79.     strcpy(res_name, "*xim.");
  80.     } else {
  81.     _XSnprintf(res_name, size, "%s.xim.", im->core.res_name);
  82.     }
  83.     if(im->core.res_class == NULL) {
  84.     strcpy(res_class, "*Xim.");
  85.     } else {
  86.     _XSnprintf(res_class, size, "%s.Xim.", im->core.res_class);
  87.     }
  88. }
  89.  
  90. #ifdef XIM_CONNECTABLE
  91. Private Bool
  92. _XimCheckBool(str)
  93.     char    *str;
  94. {
  95.     if(!strcmp(str, "True") || !strcmp(str, "true") ||
  96.        !strcmp(str, "Yes")  || !strcmp(str, "yes")  ||
  97.        !strcmp(str, "ON")   || !strcmp(str, "on"))
  98.     return True;
  99.     return False;
  100. }
  101.  
  102. Public void
  103. _XimSetProtoResource(im)
  104.     Xim         im;
  105. {
  106.     char     xim_res_name[256];
  107.     char     xim_res_class[256];
  108.     char     res_name[256];
  109.     char     res_class[256];
  110.     char    *str_type;
  111.     XrmValue     value;
  112.     XIMStyle     preedit_style = 0;
  113.     XIMStyle     status_style = 0;
  114.     XIMStyles    *imstyles;
  115.  
  116.     if (!im->core.rdb)
  117.     return;
  118.  
  119.     _XimGetResourceName(im, xim_res_name, xim_res_class, 256);
  120.  
  121.     _XSnprintf(res_name, sizeof(res_name), "%s%s", xim_res_name, "useAuth");
  122.     _XSnprintf(res_class, sizeof(res_class), "%s%s", xim_res_class, "UseAuth");
  123.     bzero(&value, sizeof(XrmValue));
  124.     if(XrmGetResource(im->core.rdb, res_name, res_class, &str_type, &value)) {
  125.     if(_XimCheckBool(value.addr)) {
  126.         MARK_USE_AUTHORIZATION_FUNC(im);
  127.     }
  128.     }
  129.  
  130.     _XSnprintf(res_name, sizeof(res_name), "%s%s", xim_res_name,
  131.            "delaybinding");
  132.     _XSnprintf(res_class, sizeof(res_class), "%s%s", xim_res_class,
  133.            "Delaybinding");
  134.     bzero(&value, sizeof(XrmValue));
  135.     if(XrmGetResource(im->core.rdb, res_name, res_class, &str_type, &value)) {
  136.     if(_XimCheckBool(value.addr)) {
  137.         MARK_DELAYBINDABLE(im);
  138.     }
  139.     }
  140.  
  141.     _XSnprintf(res_name, sizeof(res_name), "%s%s", xim_res_name, "reconnect");
  142.     _XSnprintf(res_class, sizeof(res_class), "%s%s", xim_res_class,
  143.            "Reconnect");
  144.     bzero(&value, sizeof(XrmValue));
  145.     if(XrmGetResource(im->core.rdb, res_name, res_class, &str_type, &value)) {
  146.     if(_XimCheckBool(value.addr)) {
  147.         MARK_RECONNECTABLE(im);
  148.     }
  149.     }
  150.  
  151.     if(!IS_CONNECTABLE(im))
  152.     return;
  153.  
  154.     _XSnprintf(res_name, sizeof(res_name), "%s%s", xim_res_name,
  155.            "preeditDefaultStyle");
  156.     _XSnprintf(res_class, sizeof(res_class), "%s%s", xim_res_class,
  157.            "PreeditDefaultStyle");
  158.     if(XrmGetResource(im->core.rdb, res_name, res_class, &str_type, &value)) {
  159.     if(!strcmp(value.addr, "XIMPreeditArea"))
  160.         preedit_style = XIMPreeditArea;
  161.     else if(!strcmp(value.addr, "XIMPreeditCallbacks"))
  162.         preedit_style = XIMPreeditCallbacks;
  163.     else if(!strcmp(value.addr, "XIMPreeditPosition"))
  164.         preedit_style = XIMPreeditPosition;
  165.     else if(!strcmp(value.addr, "XIMPreeditNothing"))
  166.         preedit_style = XIMPreeditNothing;
  167.     else if(!strcmp(value.addr, "XIMPreeditNone"))
  168.         preedit_style = XIMPreeditNone;
  169.     }
  170.     if(!preedit_style)
  171.     preedit_style = XIMPreeditNothing;
  172.  
  173.     _XSnprintf(res_name, sizeof(res_name), "%s%s", xim_res_name,
  174.            "statusDefaultStyle");
  175.     _XSnprintf(res_class, sizeof(res_class), "%s%s", xim_res_class,
  176.            "StatusDefaultStyle");
  177.     if(XrmGetResource(im->core.rdb, res_name, res_class, &str_type, &value)) {
  178.     if(!strcmp(value.addr, "XIMStatusArea"))
  179.         status_style = XIMStatusArea;
  180.     else if(!strcmp(value.addr, "XIMStatusCallbacks"))
  181.         status_style = XIMStatusCallbacks;
  182.     else if(!strcmp(value.addr, "XIMStatusNothing"))
  183.         status_style = XIMStatusNothing;
  184.     else if(!strcmp(value.addr, "XIMStatusNone"))
  185.         status_style = XIMStatusNone;
  186.     }
  187.     if(!status_style)
  188.     status_style = XIMStatusNothing;
  189.  
  190.     if(!(imstyles = (XIMStyles *)Xmalloc(sizeof(XIMStyles) + sizeof(XIMStyle))))
  191.     return;
  192.     imstyles->count_styles = 1;
  193.     imstyles->supported_styles =
  194.             (XIMStyle *)((char *)imstyles + sizeof(XIMStyles));
  195.     imstyles->supported_styles[0] = preedit_style | status_style;
  196.     im->private.proto.default_styles = imstyles;
  197. }
  198. #endif /* XIM_CONNECTABLE */
  199.  
  200. static char *supported_local_im_values_list[] = {
  201.     XNQueryInputStyle,
  202.     XNResourceName,
  203.     XNResourceClass,
  204.     XNDestroyCallback,
  205.     XNQueryIMValuesList,
  206.     XNQueryICValuesList,
  207.     XNVisiblePosition,
  208.     (char *)NULL
  209. };
  210.  
  211. static char *supported_local_ic_values_list[] = {
  212.     XNInputStyle,
  213.     XNClientWindow,
  214.     XNFocusWindow,
  215.     XNResourceName,
  216.     XNResourceClass,
  217.     XNGeometryCallback,
  218.     XNFilterEvents,
  219.     XNDestroyCallback,
  220.     XNStringConversionCallback,
  221.     XNStringConversion,
  222.     XNResetState,
  223.     XNHotKey,
  224.     XNHotKeyState,
  225.     XNPreeditAttributes,
  226.     XNStatusAttributes,
  227.     XNArea,
  228.     XNAreaNeeded,
  229.     XNSpotLocation,
  230.     XNColormap,
  231.     XNStdColormap,
  232.     XNForeground,
  233.     XNBackground,
  234.     XNBackgroundPixmap,
  235.     XNFontSet,
  236.     XNLineSpace,
  237.     XNCursor,
  238.     XNPreeditStartCallback,
  239.     XNPreeditDoneCallback,
  240.     XNPreeditDrawCallback,
  241.     XNPreeditCaretCallback,
  242.     XNStatusStartCallback,
  243.     XNStatusDoneCallback,
  244.     XNStatusDrawCallback,
  245.     XNPreeditState,
  246.     XNPreeditStateNotifyCallback,
  247.     (char *)NULL
  248. };
  249.  
  250. static XIMStyle supported_local_styles[] = {
  251.     XIMPreeditNone    | XIMStatusNone,
  252.     XIMPreeditNothing    | XIMStatusNothing,
  253.     0                        /* dummy */
  254. };
  255.  
  256. Private  Bool
  257. _XimDefaultStyles(info, top, parm, mode)
  258.     XimValueOffsetInfo      info;
  259.     XPointer           top;
  260.     XPointer           parm;            /* unused */
  261.     unsigned long      mode;            /* unused */
  262. {
  263.     XIMStyles         *styles;
  264.     XIMStyles        **out;
  265.     register int      i;
  266.     unsigned int      n;
  267.     int              len;
  268.     XPointer          tmp;
  269.  
  270.     n = XIMNumber(supported_local_styles) - 1;
  271.     len = sizeof(XIMStyles) + sizeof(XIMStyle) * n;
  272.     if(!(tmp = (XPointer)Xmalloc(len))) {
  273.     return False;
  274.     }
  275.     bzero(tmp, len);
  276.  
  277.     styles = (XIMStyles *)tmp;
  278.     if (n > 0) {
  279.     styles->count_styles = (unsigned short)n;
  280.     styles->supported_styles =
  281.                 (XIMStyle *)((char *)tmp + sizeof(XIMStyles));
  282.     for(i = 0; i < n; i++) {
  283.         styles->supported_styles[i] = supported_local_styles[i];
  284.     }
  285.     }
  286.  
  287.     out = (XIMStyles **)((char *)top + info->offset);
  288.     *out = styles;
  289.     return True;
  290. }
  291.  
  292. Private  Bool
  293. _XimDefaultIMValues(info, top, parm, mode)
  294.     XimValueOffsetInfo      info;
  295.     XPointer           top;
  296.     XPointer           parm;            /* unused */
  297.     unsigned long      mode;            /* unused */
  298. {
  299.     XIMValuesList     *values_list;
  300.     XIMValuesList    **out;
  301.     register int      i;
  302.     unsigned int      n;
  303.     int              len;
  304.     XPointer          tmp;
  305.  
  306.     n = XIMNumber(supported_local_im_values_list) - 1;
  307.     len = sizeof(XIMValuesList) + sizeof(char **) * n;
  308.     if(!(tmp = (XPointer)Xmalloc(len))) {
  309.     return False;
  310.     }
  311.     bzero(tmp, len);
  312.  
  313.     values_list = (XIMValuesList *)tmp;
  314.     if (n > 0) {
  315.     values_list->count_values = (unsigned short)n;
  316.     values_list->supported_values
  317.              = (char **)((char *)tmp + sizeof(XIMValuesList));
  318.     for(i = 0; i < n; i++) {
  319.         values_list->supported_values[i]
  320.                  = supported_local_im_values_list[i];
  321.     }
  322.     }
  323.  
  324.     out = (XIMValuesList **)((char *)top + info->offset);
  325.     *out = values_list;
  326.     return True;
  327. }
  328.  
  329. Private  Bool
  330. _XimDefaultICValues(info, top, parm, mode)
  331.     XimValueOffsetInfo      info;
  332.     XPointer           top;
  333.     XPointer           parm;            /* unused */
  334.     unsigned long      mode;            /* unused */
  335. {
  336.     XIMValuesList     *values_list;
  337.     XIMValuesList    **out;
  338.     register int      i;
  339.     unsigned int      n;
  340.     int              len;
  341.     XPointer          tmp;
  342.  
  343.     n = XIMNumber(supported_local_ic_values_list) - 1;
  344.     len = sizeof(XIMValuesList) + sizeof(char **) * n;
  345.     if(!(tmp = (XPointer)Xmalloc(len))) {
  346.     return False;
  347.     }
  348.     bzero(tmp, len);
  349.  
  350.     values_list = (XIMValuesList *)tmp;
  351.     if (n > 0) {
  352.     values_list->count_values = (unsigned short)n;
  353.     values_list->supported_values
  354.              = (char **)((char *)tmp + sizeof(XIMValuesList));
  355.     for(i = 0; i < n; i++) {
  356.         values_list->supported_values[i]
  357.                  = supported_local_ic_values_list[i];
  358.     }
  359.     }
  360.  
  361.     out = (XIMValuesList **)((char *)top + info->offset);
  362.     *out = values_list;
  363.     return True;
  364. }
  365.  
  366. Private  Bool
  367. _XimDefaultVisiblePos(info, top, parm, mode)
  368.     XimValueOffsetInfo      info;
  369.     XPointer           top;
  370.     XPointer           parm;            /* unused */
  371.     unsigned long      mode;            /* unused */
  372. {
  373.     Bool        *out;
  374.  
  375.     out = (Bool *)((char *)top + info->offset);
  376.     *out = False;
  377.     return True;
  378. }
  379.  
  380. Private  Bool
  381. _XimDefaultFocusWindow(info, top, parm, mode)
  382.     XimValueOffsetInfo     info;
  383.     XPointer          top;
  384.     XPointer          parm;
  385.     unsigned long     mode;
  386. {
  387.     Xic             ic = (Xic)parm;
  388.     Window        *out;
  389.  
  390.     if(ic->core.client_window == (Window)NULL) {
  391.     return True;
  392.     }
  393.  
  394.     out = (Window *)((char *)top + info->offset);
  395.     *out = ic->core.client_window;
  396.     return True;
  397. }
  398.  
  399. Private  Bool
  400. _XimDefaultResName(info, top, parm, mode)
  401.     XimValueOffsetInfo      info;
  402.     XPointer           top;
  403.     XPointer           parm;
  404.     unsigned long      mode;
  405. {
  406.     Xic              ic = (Xic)parm;
  407.     Xim              im = (Xim)ic->core.im;
  408.     int              len;
  409.     char         *name;
  410.     char        **out;
  411.  
  412.     if(im->core.res_name == (char *)NULL) {
  413.     return True;
  414.     }
  415.     len = strlen(im->core.res_name);
  416.     if(!(name = (char *)Xmalloc(len + 1))) {
  417.     return False;
  418.     }
  419.     (void)strcpy(name, im->core.res_name);
  420.     name[len] = '\0';
  421.  
  422.     out = (char **)((char *)top + info->offset);
  423.     *out = name;
  424.     return True;
  425. }
  426.  
  427. Private  Bool
  428. _XimDefaultResClass(info, top, parm, mode)
  429.     XimValueOffsetInfo       info;
  430.     XPointer            top;
  431.     XPointer            parm;
  432.     unsigned long       mode;
  433. {
  434.     Xic              ic = (Xic)parm;
  435.     Xim              im = (Xim)ic->core.im;
  436.     int              len;
  437.     char         *class;
  438.     char        **out;
  439.  
  440.     if(im->core.res_class == (char *)NULL) {
  441.     return True;
  442.     }
  443.     len = strlen(im->core.res_class);
  444.     if(!(class = (char *)Xmalloc(len + 1))) {
  445.     return False;
  446.     }
  447.     (void)strcpy(class, im->core.res_class);
  448.     class[len] = '\0';
  449.  
  450.     out = (char **)((char *)top + info->offset);
  451.     *out = class;
  452.     return True;
  453. }
  454.  
  455. Private  Bool
  456. _XimDefaultDestroyCB(info, top, parm, mode)
  457.     XimValueOffsetInfo      info;
  458.     XPointer           top;
  459.     XPointer           parm;
  460.     unsigned long      mode;
  461. {
  462.     Xic             ic = (Xic)parm;
  463.     Xim             im = (Xim)ic->core.im;
  464.     XIMCallback        *out;
  465.  
  466.     out = (XIMCallback *)((char *)top + info->offset);
  467.     *out = im->core.destroy_callback;
  468.     return True;
  469. }
  470.  
  471. Private  Bool
  472. _XimDefaultResetState(info, top, parm, mode)
  473.     XimValueOffsetInfo      info;
  474.     XPointer           top;
  475.     XPointer           parm;
  476.     unsigned long      mode;
  477. {
  478.     XIMResetState    *out;
  479.  
  480.     out = (XIMResetState *)((char *)top + info->offset);
  481.     *out = XIMInitialState;
  482.     return True;
  483. }
  484.  
  485. Private  Bool
  486. _XimDefaultHotKeyState(info, top, parm, mode)
  487.     XimValueOffsetInfo      info;
  488.     XPointer           top;
  489.     XPointer           parm;
  490.     unsigned long      mode;
  491. {
  492.     XIMHotKeyState    *out;
  493.  
  494.     out = (XIMHotKeyState *)((char *)top + info->offset);
  495.     *out = XIMHotKeyStateOFF;
  496.     return True;
  497. }
  498.  
  499. Private  Bool
  500. _XimDefaultArea(info, top, parm, mode)
  501.     XimValueOffsetInfo     info;
  502.     XPointer          top;
  503.     XPointer          parm;
  504.     unsigned long     mode;
  505. {
  506.     Xic             ic = (Xic)parm;
  507.     Xim             im = (Xim)ic->core.im;
  508.     Window         root_return;
  509.     int             x_return, y_return;
  510.     unsigned int     width_return, height_return;
  511.     unsigned int     border_width_return;
  512.     unsigned int     depth_return;
  513.     XRectangle         area;
  514.     XRectangle        *out;
  515.  
  516.     if(ic->core.focus_window == (Window)NULL) {
  517.     return True;
  518.     }
  519.     if(XGetGeometry(im->core.display, (Drawable)ic->core.focus_window,
  520.         &root_return, &x_return, &y_return, &width_return,
  521.         &height_return, &border_width_return, &depth_return)
  522.         == (Status)NULL) {
  523.     return True;
  524.     }
  525.     area.x    = 0;
  526.     area.y    = 0;
  527.     area.width    = width_return;
  528.     area.height    = height_return;
  529.  
  530.     out = (XRectangle *)((char *)top + info->offset);
  531.     *out = area;
  532.     return True;
  533. }
  534.  
  535. Private  Bool
  536. _XimDefaultColormap(info, top, parm, mode)
  537.     XimValueOffsetInfo     info;
  538.     XPointer          top;
  539.     XPointer          parm;
  540.     unsigned long     mode;
  541. {
  542.     Xic             ic = (Xic)parm;
  543.     Xim             im = (Xim)ic->core.im;
  544.     XWindowAttributes     win_attr;
  545.     Colormap        *out;
  546.  
  547.     if(ic->core.client_window == (Window)NULL) {
  548.     return True;
  549.     }
  550.     if(XGetWindowAttributes(im->core.display, ic->core.client_window,
  551.                     &win_attr) == (Status)NULL) {
  552.     return True;
  553.     }
  554.    
  555.     out = (Colormap *)((char *)top + info->offset);
  556.     *out = win_attr.colormap;
  557.     return True;
  558. }
  559.  
  560. Private  Bool
  561. _XimDefaultStdColormap(info, top, parm, mode)
  562.     XimValueOffsetInfo     info;
  563.     XPointer          top;
  564.     XPointer          parm;
  565.     unsigned long     mode;
  566. {
  567.     Atom        *out;
  568.  
  569.     out = (Atom *)((char *)top + info->offset);
  570.     *out = (Atom)0;
  571.     return True;
  572. }
  573.  
  574. Private  Bool
  575. _XimDefaultFg(info, top, parm, mode)
  576.     XimValueOffsetInfo     info;
  577.     XPointer          top;
  578.     XPointer          parm;
  579.     unsigned long     mode;
  580. {
  581.     Xic             ic = (Xic)parm;
  582.     Xim             im = (Xim)ic->core.im;
  583.     unsigned long     fg;
  584.     unsigned long    *out;
  585.  
  586.     fg = WhitePixel(im->core.display, DefaultScreen(im->core.display));
  587.     out = (unsigned long *)((char *)top + info->offset);
  588.     *out = fg;
  589.     return True;
  590. }
  591.  
  592. Private  Bool
  593. _XimDefaultBg(info, top, parm, mode)
  594.     XimValueOffsetInfo     info;
  595.     XPointer          top;
  596.     XPointer          parm;
  597.     unsigned long     mode;
  598. {
  599.     Xic             ic = (Xic)parm;
  600.     Xim             im = (Xim)ic->core.im;
  601.     unsigned long     bg;
  602.     unsigned long    *out;
  603.  
  604.     bg = BlackPixel(im->core.display, DefaultScreen(im->core.display));
  605.     out = (unsigned long *)((char *)top + info->offset);
  606.     *out = bg;
  607.     return True;
  608. }
  609.  
  610. Private  Bool
  611. _XimDefaultBgPixmap(info, top, parm, mode)
  612.     XimValueOffsetInfo     info;
  613.     XPointer          top;
  614.     XPointer          parm;
  615.     unsigned long     mode;
  616. {
  617.     Pixmap        *out;
  618.  
  619.     out = (Pixmap *)((char *)top + info->offset);
  620.     *out = (Pixmap)0;
  621.     return True;
  622. }
  623.  
  624. Private  Bool
  625. _XimDefaultFontSet(info, top, parm, mode)
  626.     XimValueOffsetInfo     info;
  627.     XPointer          top;
  628.     XPointer          parm;
  629.     unsigned long     mode;
  630. {
  631.     XFontSet        *out;
  632.  
  633.     out = (XFontSet *)((char *)top + info->offset);
  634.     *out = 0;
  635.     return True;
  636. }
  637.  
  638. Private  Bool
  639. _XimDefaultLineSpace(info, top, parm, mode)
  640.     XimValueOffsetInfo     info;
  641.     XPointer          top;
  642.     XPointer          parm;
  643.     unsigned long     mode;
  644. {
  645.     Xic             ic = (Xic)parm;
  646.     XFontSet         fontset;
  647.     XFontSetExtents    *fset_extents;
  648.     int             line_space = 0;
  649.     int            *out;
  650.  
  651.     if(mode & XIM_PREEDIT_ATTR) {
  652.     fontset = ic->core.preedit_attr.fontset;
  653.     } else if(mode & XIM_STATUS_ATTR) {
  654.     fontset = ic->core.status_attr.fontset;
  655.     } else {
  656.     return True;
  657.     }
  658.     if (fontset) {
  659.     fset_extents = XExtentsOfFontSet(fontset);
  660.     line_space = fset_extents->max_logical_extent.height;
  661.     }
  662.     out = (int *)((char *)top + info->offset);
  663.     *out = line_space;
  664.     return True;
  665. }
  666.  
  667. Private  Bool
  668. _XimDefaultCursor(info, top, parm, mode)
  669.     XimValueOffsetInfo     info;
  670.     XPointer          top;
  671.     XPointer          parm;
  672.     unsigned long     mode;
  673. {
  674.     Cursor        *out;
  675.  
  676.     out = (Cursor *)((char *)top + info->offset);
  677.     *out = (Cursor)0;
  678.     return True;
  679. }
  680.  
  681. Private  Bool
  682. _XimDefaultPreeditState(info, top, parm, mode)
  683.     XimValueOffsetInfo     info;
  684.     XPointer          top;
  685.     XPointer          parm;
  686.     unsigned long     mode;
  687. {
  688.     XIMPreeditState    *out;
  689.  
  690.     out = (XIMPreeditState *)((char *)top + info->offset);
  691.     *out = XIMPreeditDisable;
  692.     return True;
  693. }
  694.  
  695. Private  Bool
  696. _XimDefaultNest(info, top, parm, mode)
  697.     XimValueOffsetInfo     info;
  698.     XPointer          top;
  699.     XPointer          parm;
  700.     unsigned long     mode;
  701. {
  702.     return True;
  703. }
  704.  
  705. Private  Bool
  706. _XimEncodeCallback(info, top, val)
  707.     XimValueOffsetInfo     info;
  708.     XPointer          top;
  709.     XPointer          val;
  710. {
  711.     XIMCallback        *out;
  712.  
  713.     out = (XIMCallback *)((char *)top + info->offset);
  714.     *out = *((XIMCallback *)val);
  715.     return True;
  716. }
  717.  
  718. Private  Bool
  719. _XimEncodeString(info, top, val)
  720.     XimValueOffsetInfo      info;
  721.     XPointer           top;
  722.     XPointer           val;
  723. {
  724.     int              len;
  725.     char         *string;
  726.     char        **out;
  727.  
  728.     if(val == (XPointer)NULL) {
  729.     return False;
  730.     }
  731.     len = strlen((char *)val);
  732.     if(!(string = (char *)Xmalloc(len + 1))) {
  733.     return False;
  734.     }
  735.     (void)strcpy(string, (char *)val);
  736.     string[len] = '\0';
  737.  
  738.     out = (char **)((char *)top + info->offset);
  739.     if(*out) {
  740.     Xfree(*out);
  741.     }
  742.     *out = string;
  743.     return True;
  744. }
  745.  
  746. Private  Bool
  747. _XimEncodeStyle(info, top, val)
  748.     XimValueOffsetInfo     info;
  749.     XPointer          top;
  750.     XPointer          val;
  751. {
  752.     XIMStyle        *out;
  753.  
  754.     out = (XIMStyle *)((char *)top + info->offset);
  755.     *out = (XIMStyle)val;
  756.     return True;
  757. }
  758.  
  759. Private  Bool
  760. _XimEncodeWindow(info, top, val)
  761.     XimValueOffsetInfo     info;
  762.     XPointer          top;
  763.     XPointer          val;
  764. {
  765.     Window        *out;
  766.  
  767.     out = (Window *)((char *)top + info->offset);
  768.     *out = (Window)val;
  769.     return True;
  770. }
  771.  
  772. Private  Bool
  773. _XimEncodeStringConv(info, top, val)
  774.     XimValueOffsetInfo         info;
  775.     XPointer              top;
  776.     XPointer              val;
  777. {
  778.     /*
  779.      * Not yet
  780.      */
  781.     return True;
  782. }
  783.  
  784. Private  Bool
  785. _XimEncodeResetState(info, top, val)
  786.     XimValueOffsetInfo     info;
  787.     XPointer          top;
  788.     XPointer          val;
  789. {
  790.     XIMResetState    *out;
  791.  
  792.     out = (XIMResetState *)((char *)top + info->offset);
  793.     *out = (XIMResetState)val;
  794.     return True;
  795. }
  796.  
  797. Private  Bool
  798. _XimEncodeHotKey(info, top, val)
  799.     XimValueOffsetInfo      info;
  800.     XPointer           top;
  801.     XPointer           val;
  802. {
  803.     XIMHotKeyTriggers     *hotkey = (XIMHotKeyTriggers *)val;
  804.     XIMHotKeyTriggers    **out;
  805.     XIMHotKeyTriggers     *key_list;
  806.     XIMHotKeyTrigger     *key;
  807.     XPointer          tmp;
  808.     int              num;
  809.     int              len;
  810.     register int      i;
  811.  
  812.     if(hotkey == (XIMHotKeyTriggers *)NULL) {
  813.     return True;
  814.     }
  815.  
  816.     if((num = hotkey->num_hot_key) == 0) {
  817.     return True;
  818.     }
  819.  
  820.     len = sizeof(XIMHotKeyTriggers) + sizeof(XIMHotKeyTrigger) * num;
  821.     if(!(tmp = (XPointer)Xmalloc(len))) {
  822.     return False;
  823.     }
  824.  
  825.     key_list = (XIMHotKeyTriggers *)tmp;
  826.     key = (XIMHotKeyTrigger *)((char *)tmp + sizeof(XIMHotKeyTriggers));
  827.  
  828.     for(i = 0; i < num; i++) {
  829.     key[i] = hotkey->key[i];
  830.     }
  831.  
  832.     key_list->num_hot_key = num;
  833.     key_list->key = key;
  834.  
  835.     out = (XIMHotKeyTriggers **)((char *)top + info->offset);
  836.     *out = key_list;
  837.     return True;
  838. }
  839.  
  840. Private  Bool
  841. _XimEncodeHotKetState(info, top, val)
  842.     XimValueOffsetInfo     info;
  843.     XPointer          top;
  844.     XPointer          val;
  845. {
  846.     XIMHotKeyState    *out;
  847.  
  848.     out = (XIMHotKeyState *)((char *)top + info->offset);
  849.     *out = (XIMHotKeyState)val;
  850.     return True;
  851. }
  852.  
  853. Private  Bool
  854. _XimEncodeRectangle(info, top, val)
  855.     XimValueOffsetInfo     info;
  856.     XPointer          top;
  857.     XPointer          val;
  858. {
  859.     XRectangle        *out;
  860.  
  861.     out = (XRectangle *)((char *)top + info->offset);
  862.     *out = *((XRectangle *)val);
  863.     return True;
  864. }
  865.  
  866. Private  Bool
  867. _XimEncodeSpot(info, top, val)
  868.     XimValueOffsetInfo     info;
  869.     XPointer          top;
  870.     XPointer          val;
  871. {
  872.     XPoint        *out;
  873.  
  874.     out = (XPoint *)((char *)top + info->offset);
  875.     *out = *((XPoint *)val);
  876.     return True;
  877. }
  878.  
  879. Private  Bool
  880. _XimEncodeColormap(info, top, val)
  881.     XimValueOffsetInfo     info;
  882.     XPointer          top;
  883.     XPointer          val;
  884. {
  885.     Colormap        *out;
  886.  
  887.     out = (Colormap *)((char *)top + info->offset);
  888.     *out = (Colormap)val;
  889.     return True;
  890. }
  891.  
  892. Private  Bool
  893. _XimEncodeStdColormap(info, top, val)
  894.     XimValueOffsetInfo     info;
  895.     XPointer          top;
  896.     XPointer          val;
  897. {
  898.     Atom        *out;
  899.  
  900.     out = (Atom *)((char *)top + info->offset);
  901.     *out = (Atom)val;
  902.     return True;
  903. }
  904.  
  905. Private  Bool
  906. _XimEncodeLong(info, top, val)
  907.     XimValueOffsetInfo     info;
  908.     XPointer          top;
  909.     XPointer          val;
  910. {
  911.     unsigned long    *out;
  912.  
  913.     out = (unsigned long *)((char *)top + info->offset);
  914.     *out = (unsigned long)val;
  915.     return True;
  916. }
  917.  
  918. Private  Bool
  919. _XimEncodeBgPixmap(info, top, val)
  920.     XimValueOffsetInfo     info;
  921.     XPointer          top;
  922.     XPointer          val;
  923. {
  924.     Pixmap        *out;
  925.  
  926.     out = (Pixmap *)((char *)top + info->offset);
  927.     *out = (Pixmap)val;
  928.     return True;
  929. }
  930.  
  931. Private  Bool
  932. _XimEncodeFontSet(info, top, val)
  933.     XimValueOffsetInfo     info;
  934.     XPointer          top;
  935.     XPointer          val;
  936. {
  937.     XFontSet        *out;
  938.  
  939.     out = (XFontSet *)((char *)top + info->offset);
  940.     *out = (XFontSet)val;
  941.     return True;
  942. }
  943.  
  944. Private  Bool
  945. _XimEncodeLineSpace(info, top, val)
  946.     XimValueOffsetInfo     info;
  947.     XPointer          top;
  948.     XPointer          val;
  949. {
  950.     int            *out;
  951.  
  952.     out = (int *)((char *)top + info->offset);
  953.     *out = (long)val;
  954.     return True;
  955. }
  956.  
  957. Private  Bool
  958. _XimEncodeCursor(info, top, val)
  959.     XimValueOffsetInfo     info;
  960.     XPointer          top;
  961.     XPointer          val;
  962. {
  963.     Cursor        *out;
  964.  
  965.     out = (Cursor *)((char *)top + info->offset);
  966.     *out = (Cursor)val;
  967.     return True;
  968. }
  969.  
  970. Private  Bool
  971. _XimEncodePreeditState(info, top, val)
  972.     XimValueOffsetInfo     info;
  973.     XPointer          top;
  974.     XPointer          val;
  975. {
  976.     XIMPreeditState    *out;
  977.  
  978.     out = (XIMPreeditState *)((char *)top + info->offset);
  979.     *out = (XIMPreeditState)val;
  980.     return True;
  981. }
  982.  
  983. Private  Bool
  984. _XimEncodeNest(info, top, val)
  985.     XimValueOffsetInfo     info;
  986.     XPointer          top;
  987.     XPointer          val;
  988. {
  989.     return True;
  990. }
  991.  
  992. Private  Bool
  993. _XimDecodeStyles(info, top, val)
  994.     XimValueOffsetInfo     info;
  995.     XPointer          top;
  996.     XPointer          val;
  997. {
  998.     XIMStyles        *styles;
  999.     XIMStyles        *out;
  1000.     register int     i;
  1001.     unsigned int     num;
  1002.     int             len;
  1003.     XPointer         tmp;
  1004.  
  1005.     if(val == (XPointer)NULL) {
  1006.     return False;
  1007.     }
  1008.  
  1009.     styles = *((XIMStyles **)((char *)top + info->offset));
  1010.     num = styles->count_styles;
  1011.  
  1012.     len = sizeof(XIMStyles) + sizeof(XIMStyle) * num;
  1013.     if(!(tmp = (XPointer)Xmalloc(len))) {
  1014.     return False;
  1015.     }
  1016.     bzero(tmp, len);
  1017.  
  1018.     out = (XIMStyles *)tmp;
  1019.     if(num >0) {
  1020.     out->count_styles = (unsigned short)num;
  1021.     out->supported_styles = (XIMStyle *)((char *)tmp + sizeof(XIMStyles));
  1022.     
  1023.     for(i = 0; i < num; i++) {
  1024.         out->supported_styles[i] = styles->supported_styles[i];
  1025.     }
  1026.     }
  1027.     *((XIMStyles **)val) = out;
  1028.     return True;
  1029. }
  1030.  
  1031. Private  Bool
  1032. _XimDecodeValues(info, top, val)
  1033.     XimValueOffsetInfo     info;
  1034.     XPointer          top;
  1035.     XPointer          val;
  1036. {
  1037.     XIMValuesList    *values_list;
  1038.     XIMValuesList    *out;
  1039.     register int     i;
  1040.     unsigned int     num;
  1041.     int             len;
  1042.     XPointer         tmp;
  1043.  
  1044.     if(val == (XPointer)NULL) {
  1045.     return False;
  1046.     }
  1047.  
  1048.     values_list = *((XIMValuesList **)((char *)top + info->offset));
  1049.     num = values_list->count_values;
  1050.  
  1051.     len = sizeof(XIMValuesList) + sizeof(char **) * num;
  1052.     if(!(tmp = (char *)Xmalloc(len))) {
  1053.     return False;
  1054.     }
  1055.     bzero(tmp, len);
  1056.  
  1057.     out = (XIMValuesList *)tmp;
  1058.     if(num) {
  1059.     out->count_values = (unsigned short)num;
  1060.     out->supported_values = (char **)((char *)tmp + sizeof(XIMValuesList));
  1061.     
  1062.     for(i = 0; i < num; i++) {
  1063.         out->supported_values[i] = values_list->supported_values[i];
  1064.     }
  1065.     }
  1066.     *((XIMValuesList **)val) = out;
  1067.     return True;
  1068. }
  1069.  
  1070. Private  Bool
  1071. _XimDecodeCallback(info, top, val)
  1072.     XimValueOffsetInfo     info;
  1073.     XPointer          top;
  1074.     XPointer          val;
  1075. {
  1076.     XIMCallback        *in;
  1077.     XIMCallback        *callback;
  1078.  
  1079.     in = (XIMCallback *)((char *)top + info->offset);
  1080.     if(!(callback = (XIMCallback *)Xmalloc(sizeof(XIMCallback)))) {
  1081.     return False;
  1082.     }
  1083.     callback->client_data = in->client_data;
  1084.     callback->callback    = in->callback;
  1085.  
  1086.     *((XIMCallback **)val) = callback;
  1087.     return True;
  1088. }
  1089.  
  1090. Private  Bool
  1091. _XimDecodeString(info, top, val)
  1092.     XimValueOffsetInfo     info;
  1093.     XPointer          top;
  1094.     XPointer          val;
  1095. {
  1096.     int             len = 0;
  1097.     char        *in;
  1098.     char        *string;
  1099.  
  1100.     in = *((char **)((char *)top + info->offset));
  1101.     if(in != (char *)NULL) {
  1102.     len = strlen(in);
  1103.     }
  1104.     if(!(string = (char *)Xmalloc(len + 1))) {
  1105.     return False;
  1106.     }
  1107.     if(in != (char *)NULL) {
  1108.     (void)strcpy(string, in);
  1109.     }
  1110.     string[len] = '\0';
  1111.     *((char **)val) = string;
  1112.     return True;
  1113. }
  1114.  
  1115. Private  Bool
  1116. _XimDecodeBool(info, top, val)
  1117.     XimValueOffsetInfo     info;
  1118.     XPointer          top;
  1119.     XPointer          val;
  1120. {
  1121.     Bool        *in;
  1122.  
  1123.     in = (Bool *)((char *)top + info->offset);
  1124.     *((Bool *)val) = *in;
  1125.     return True;
  1126. }
  1127.  
  1128. Private  Bool
  1129. _XimDecodeStyle(info, top, val)
  1130.     XimValueOffsetInfo     info;
  1131.     XPointer          top;
  1132.     XPointer          val;
  1133. {
  1134.     XIMStyle        *in;
  1135.  
  1136.     in = (XIMStyle *)((char *)top + info->offset);
  1137.     *((XIMStyle *)val) = *in;
  1138.     return True;
  1139. }
  1140.  
  1141. Private  Bool
  1142. _XimDecodeWindow(info, top, val)
  1143.     XimValueOffsetInfo     info;
  1144.     XPointer          top;
  1145.     XPointer          val;
  1146. {
  1147.     Window        *in;
  1148.  
  1149.     in = (Window *)((char *)top + info->offset);
  1150.     *((Window *)val) = *in;
  1151.     return True;
  1152. }
  1153.  
  1154. Private  Bool
  1155. _XimDecodeStringConv(info, top, val)
  1156.     XimValueOffsetInfo     info;
  1157.     XPointer          top;
  1158.     XPointer          val;
  1159. {
  1160.     /*
  1161.      * Not yet
  1162.      */
  1163.     return True;
  1164. }
  1165.  
  1166. Private  Bool
  1167. _XimDecodeResetState(info, top, val)
  1168.     XimValueOffsetInfo     info;
  1169.     XPointer          top;
  1170.     XPointer          val;
  1171. {
  1172.     XIMResetState    *in;
  1173.  
  1174.     in = (XIMResetState *)((char *)top + info->offset);
  1175.     *((XIMResetState *)val) = *in;
  1176.     return True;
  1177. }
  1178.  
  1179. Private  Bool
  1180. _XimDecodeHotKey(info, top, val)
  1181.     XimValueOffsetInfo     info;
  1182.     XPointer          top;
  1183.     XPointer          val;
  1184. {
  1185.     XIMHotKeyTriggers    *in;
  1186.     XIMHotKeyTriggers    *hotkey;
  1187.     XIMHotKeyTrigger    *key;
  1188.     XPointer         tmp;
  1189.     int             num;
  1190.     int             len;
  1191.     register int     i;
  1192.  
  1193.     in = *((XIMHotKeyTriggers **)((char *)top + info->offset));
  1194.     num = in->num_hot_key;
  1195.     len = sizeof(XIMHotKeyTriggers) + sizeof(XIMHotKeyTrigger) * num;
  1196.     if(!(tmp = (XPointer)Xmalloc(len))) {
  1197.     return False;
  1198.     }
  1199.  
  1200.     hotkey = (XIMHotKeyTriggers *)tmp;
  1201.     key = (XIMHotKeyTrigger *)((char *)tmp + sizeof(XIMHotKeyTriggers));
  1202.  
  1203.     for(i = 0; i < num; i++) {
  1204.     key[i] = in->key[i];
  1205.     }
  1206.     hotkey->num_hot_key = num;
  1207.     hotkey->key = key;
  1208.  
  1209.     *((XIMHotKeyTriggers **)val) = hotkey;
  1210.     return True;
  1211. }
  1212.  
  1213. Private  Bool
  1214. _XimDecodeHotKetState(info, top, val)
  1215.     XimValueOffsetInfo     info;
  1216.     XPointer          top;
  1217.     XPointer          val;
  1218. {
  1219.     XIMHotKeyState    *in;
  1220.  
  1221.     in = (XIMHotKeyState *)((char *)top + info->offset);
  1222.     *((XIMHotKeyState *)val) = *in;
  1223.     return True;
  1224. }
  1225.  
  1226. Private  Bool
  1227. _XimDecodeRectangle(info, top, val)
  1228.     XimValueOffsetInfo     info;
  1229.     XPointer          top;
  1230.     XPointer          val;
  1231. {
  1232.     XRectangle        *in;
  1233.     XRectangle        *rect;
  1234.  
  1235.     in = (XRectangle *)((char *)top + info->offset);
  1236.     if(!(rect = (XRectangle *)Xmalloc(sizeof(XRectangle)))) {
  1237.     return False;
  1238.     }
  1239.     *rect = *in;
  1240.     *((XRectangle **)val) = rect;
  1241.     return True;
  1242. }
  1243.  
  1244. Private  Bool
  1245. _XimDecodeSpot(info, top, val)
  1246.     XimValueOffsetInfo     info;
  1247.     XPointer          top;
  1248.     XPointer          val;
  1249. {
  1250.     XPoint        *in;
  1251.     XPoint        *spot;
  1252.  
  1253.     in = (XPoint *)((char *)top + info->offset);
  1254.     if(!(spot = (XPoint *)Xmalloc(sizeof(XPoint)))) {
  1255.     return False;
  1256.     }
  1257.     *spot = *in;
  1258.     *((XPoint **)val) = spot;
  1259.     return True;
  1260. }
  1261.  
  1262. Private  Bool
  1263. _XimDecodeColormap(info, top, val)
  1264.     XimValueOffsetInfo     info;
  1265.     XPointer          top;
  1266.     XPointer          val;
  1267. {
  1268.     Colormap        *in;
  1269.  
  1270.     in = (Colormap *)((char *)top + info->offset);
  1271.     *((Colormap *)val) = *in;
  1272.     return True;
  1273. }
  1274.  
  1275. Private  Bool
  1276. _XimDecodeStdColormap(info, top, val)
  1277.     XimValueOffsetInfo     info;
  1278.     XPointer          top;
  1279.     XPointer          val;
  1280. {
  1281.     Atom        *in;
  1282.  
  1283.     in = (Atom *)((char *)top + info->offset);
  1284.     *((Atom *)val) = *in;
  1285.     return True;
  1286. }
  1287.  
  1288. Private  Bool
  1289. _XimDecodeLong(info, top, val)
  1290.     XimValueOffsetInfo     info;
  1291.     XPointer          top;
  1292.     XPointer          val;
  1293. {
  1294.     unsigned long    *in;
  1295.  
  1296.     in = (unsigned long *)((char *)top + info->offset);
  1297.     *((unsigned long *)val) = *in;
  1298.     return True;
  1299. }
  1300.  
  1301. Private  Bool
  1302. _XimDecodeBgPixmap(info, top, val)
  1303.     XimValueOffsetInfo     info;
  1304.     XPointer          top;
  1305.     XPointer          val;
  1306. {
  1307.     Pixmap        *in;
  1308.  
  1309.     in = (Pixmap *)((char *)top + info->offset);
  1310.     *((Pixmap *)val) = *in;
  1311.     return True;
  1312. }
  1313.  
  1314. Private  Bool
  1315. _XimDecodeFontSet(info, top, val)
  1316.     XimValueOffsetInfo     info;
  1317.     XPointer          top;
  1318.     XPointer          val;
  1319. {
  1320.     XFontSet        *in;
  1321.  
  1322.     in = (XFontSet *)((char *)top + info->offset);
  1323.     *((XFontSet *)val) = *in;
  1324.     return True;
  1325. }
  1326.  
  1327. Private  Bool
  1328. _XimDecodeLineSpace(info, top, val)
  1329.     XimValueOffsetInfo     info;
  1330.     XPointer          top;
  1331.     XPointer          val;
  1332. {
  1333.     int        *in;
  1334.  
  1335.     in = (int *)((char *)top + info->offset);
  1336.     *((int *)val) = *in;
  1337.     return True;
  1338. }
  1339.  
  1340. Private  Bool
  1341. _XimDecodeCursor(info, top, val)
  1342.     XimValueOffsetInfo     info;
  1343.     XPointer          top;
  1344.     XPointer          val;
  1345. {
  1346.     Cursor        *in;
  1347.  
  1348.     in = (Cursor *)((char *)top + info->offset);
  1349.     *((Cursor *)val) = *in;
  1350.     return True;
  1351. }
  1352.  
  1353. Private  Bool
  1354. _XimDecodePreeditState(info, top, val)
  1355.     XimValueOffsetInfo     info;
  1356.     XPointer          top;
  1357.     XPointer          val;
  1358. {
  1359.     XIMPreeditState    *in;
  1360.  
  1361.     in = (XIMPreeditState *)((char *)top + info->offset);
  1362.     *((XIMPreeditState *)val) = *in;
  1363.     return True;
  1364. }
  1365.  
  1366. Private  Bool
  1367. _XimDecodeNest(info, top, val)
  1368.     XimValueOffsetInfo     info;
  1369.     XPointer          top;
  1370.     XPointer          val;
  1371. {
  1372.     return True;
  1373. }
  1374.  
  1375. static    XIMResource    im_resources[] = {
  1376.     {XNQueryInputStyle,           0, XimType_XIMStyles,    0, 0, 0},
  1377.     {XNDestroyCallback,           0,  0,            0, 0, 0},
  1378.     {XNResourceName,           0, XimType_STRING8,        0, 0, 0},
  1379.     {XNResourceClass,           0, XimType_STRING8,        0, 0, 0},
  1380.     {XNQueryIMValuesList,       0, 0,            0, 0, 0},
  1381.     {XNQueryICValuesList,       0, 0,            0, 0, 0},
  1382.     {XNVisiblePosition,           0, 0,            0, 0, 0}
  1383. };
  1384.  
  1385. static    XIMResource    im_inner_resources[] = {
  1386.     {XNDestroyCallback,           0, 0,            0, 0, 0},
  1387.     {XNResourceName,           0, XimType_STRING8,        0, 0, 0},
  1388.     {XNResourceClass,           0, XimType_STRING8,        0, 0, 0},
  1389.     {XNQueryIMValuesList,       0, 0,            0, 0, 0},
  1390.     {XNQueryICValuesList,       0, 0,            0, 0, 0},
  1391.     {XNVisiblePosition,           0, 0,            0, 0, 0}
  1392. };
  1393.  
  1394. static    XIMResource    ic_resources[] = {
  1395.     {XNInputStyle,           0, XimType_CARD32,        0, 0, 0},
  1396.     {XNClientWindow,           0, XimType_Window,        0, 0, 0},
  1397.     {XNFocusWindow,           0, XimType_Window,        0, 0, 0},
  1398.     {XNResourceName,           0, XimType_STRING8,        0, 0, 0},
  1399.     {XNResourceClass,           0, XimType_STRING8,        0, 0, 0},
  1400.     {XNGeometryCallback,       0, 0,            0, 0, 0},
  1401.     {XNFilterEvents,           0, XimType_CARD32,        0, 0, 0},
  1402.     {XNDestroyCallback,           0, 0,            0, 0, 0},
  1403.     {XNStringConversionCallback,   0, 0,            0, 0, 0},
  1404.     {XNStringConversion,       0, XimType_XIMStringConversion,0, 0, 0},
  1405.     {XNResetState,           0, 0,            0, 0, 0},
  1406.     {XNHotKey,               0, XimType_XIMHotKeyTriggers,0, 0, 0},
  1407.     {XNHotKeyState,           0, XimType_XIMHotKeyState,     0, 0, 0},
  1408.     {XNPreeditAttributes,       0, XimType_NEST,        0, 0, 0},
  1409.     {XNStatusAttributes,       0, XimType_NEST,        0, 0, 0},
  1410.     {XNArea,               0, XimType_XRectangle,    0, 0, 0},
  1411.     {XNAreaNeeded,           0, XimType_XRectangle,    0, 0, 0},
  1412.     {XNSpotLocation,           0, XimType_XPoint,        0, 0, 0},
  1413.     {XNColormap,           0, XimType_CARD32,        0, 0, 0},
  1414.     {XNStdColormap,           0, XimType_CARD32,        0, 0, 0},
  1415.     {XNForeground,           0, XimType_CARD32,        0, 0, 0},
  1416.     {XNBackground,           0, XimType_CARD32,        0, 0, 0},
  1417.     {XNBackgroundPixmap,       0, XimType_CARD32,        0, 0, 0},
  1418.     {XNFontSet,               0, XimType_XFontSet,        0, 0, 0},
  1419.     {XNLineSpace,           0, XimType_CARD32,        0, 0, 0},
  1420.     {XNCursor,               0, XimType_CARD32,        0, 0, 0},
  1421.     {XNPreeditStartCallback,       0, 0,            0, 0, 0},
  1422.     {XNPreeditDoneCallback,       0, 0,            0, 0, 0},
  1423.     {XNPreeditDrawCallback,       0, 0,            0, 0, 0},
  1424.     {XNPreeditCaretCallback,       0, 0,            0, 0, 0},
  1425.     {XNStatusStartCallback,       0, 0,            0, 0, 0},
  1426.     {XNStatusDoneCallback,       0, 0,            0, 0, 0},
  1427.     {XNStatusDrawCallback,       0, 0,            0, 0, 0},
  1428.     {XNPreeditState,           0, 0,            0, 0, 0},
  1429.     {XNPreeditStateNotifyCallback, 0, 0,            0, 0, 0},
  1430. };
  1431.  
  1432. static    XIMResource    ic_inner_resources[] = {
  1433.     {XNResourceName,           0, XimType_STRING8,        0, 0, 0},
  1434.     {XNResourceClass,           0, XimType_STRING8,        0, 0, 0},
  1435.     {XNGeometryCallback,       0, 0,            0, 0, 0},
  1436.     {XNDestroyCallback,           0, 0,            0, 0, 0},
  1437.     {XNStringConversionCallback,   0, 0,            0, 0, 0},
  1438.     {XNPreeditStartCallback,       0, 0,            0, 0, 0},
  1439.     {XNPreeditDoneCallback,       0, 0,            0, 0, 0},
  1440.     {XNPreeditDrawCallback,       0, 0,            0, 0, 0},
  1441.     {XNPreeditCaretCallback,       0, 0,            0, 0, 0},
  1442.     {XNStatusStartCallback,       0, 0,            0, 0, 0},
  1443.     {XNStatusDoneCallback,       0, 0,            0, 0, 0},
  1444.     {XNStatusDrawCallback,       0, 0,            0, 0, 0},
  1445.     {XNPreeditStateNotifyCallback, 0, 0,            0, 0, 0},
  1446. };
  1447.  
  1448. static XimValueOffsetInfoRec im_attr_info[] = {
  1449.     {XNQueryInputStyle,         0,
  1450.     XOffsetOf(XimDefIMValues, styles),
  1451.     _XimDefaultStyles,     NULL,            _XimDecodeStyles},
  1452.  
  1453.     {XNDestroyCallback,         0,
  1454.     XOffsetOf(XimDefIMValues, destroy_callback),
  1455.     NULL,              _XimEncodeCallback,    _XimDecodeCallback},
  1456.  
  1457.     {XNResourceName,         0,
  1458.     XOffsetOf(XimDefIMValues, res_name),
  1459.     NULL,              _XimEncodeString,    _XimDecodeString},
  1460.  
  1461.     {XNResourceClass,         0,
  1462.     XOffsetOf(XimDefIMValues, res_class),
  1463.     NULL,              _XimEncodeString,    _XimDecodeString},
  1464.  
  1465.     {XNQueryIMValuesList,         0,
  1466.     XOffsetOf(XimDefIMValues, im_values_list),
  1467.     _XimDefaultIMValues,     NULL,            _XimDecodeValues},
  1468.  
  1469.     {XNQueryICValuesList,         0,
  1470.     XOffsetOf(XimDefIMValues, ic_values_list),
  1471.     _XimDefaultICValues,     NULL,            _XimDecodeValues},
  1472.  
  1473.     {XNVisiblePosition,             0,
  1474.     XOffsetOf(XimDefIMValues, visible_position),
  1475.     _XimDefaultVisiblePos,     NULL,            _XimDecodeBool}
  1476. };
  1477.  
  1478. static XimValueOffsetInfoRec ic_attr_info[] = {
  1479.     {XNInputStyle,         0,
  1480.     XOffsetOf(XimDefICValues, input_style),
  1481.     NULL,             _XimEncodeStyle,    _XimDecodeStyle},
  1482.  
  1483.     {XNClientWindow,         0,
  1484.     XOffsetOf(XimDefICValues, client_window),
  1485.     NULL,             _XimEncodeWindow,    _XimDecodeWindow},
  1486.  
  1487.     {XNFocusWindow,         0,
  1488.     XOffsetOf(XimDefICValues, focus_window),
  1489.     _XimDefaultFocusWindow,  _XimEncodeWindow,    _XimDecodeWindow},
  1490.  
  1491.     {XNResourceName,         0,
  1492.     XOffsetOf(XimDefICValues, res_name),
  1493.     _XimDefaultResName,     _XimEncodeString,    _XimDecodeString},
  1494.  
  1495.     {XNResourceClass,         0,
  1496.     XOffsetOf(XimDefICValues, res_class),
  1497.     _XimDefaultResClass,     _XimEncodeString,    _XimDecodeString},
  1498.  
  1499.     {XNGeometryCallback,     0,
  1500.     XOffsetOf(XimDefICValues, geometry_callback),
  1501.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1502.  
  1503.     {XNFilterEvents,         0,
  1504.     XOffsetOf(XimDefICValues, filter_events),
  1505.     NULL,             NULL,            _XimDecodeLong},
  1506.  
  1507.     {XNDestroyCallback,         0,
  1508.     XOffsetOf(XimDefICValues, destroy_callback),
  1509.     _XimDefaultDestroyCB,     _XimEncodeCallback,    _XimDecodeCallback},
  1510.  
  1511.     {XNStringConversionCallback, 0,
  1512.     XOffsetOf(XimDefICValues, string_conversion_callback),
  1513.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1514.  
  1515.     {XNStringConversion,     0,
  1516.     XOffsetOf(XimDefICValues, string_conversion),
  1517.     NULL,             _XimEncodeStringConv,    _XimDecodeStringConv},
  1518.  
  1519.     {XNResetState,         0,
  1520.     XOffsetOf(XimDefICValues, reset_state),
  1521.     _XimDefaultResetState,     _XimEncodeResetState,    _XimDecodeResetState},
  1522.  
  1523.     {XNHotKey,             0,
  1524.     XOffsetOf(XimDefICValues, hotkey),
  1525.     NULL,             _XimEncodeHotKey,    _XimDecodeHotKey},
  1526.  
  1527.     {XNHotKeyState,         0,
  1528.     XOffsetOf(XimDefICValues, hotkey_state),
  1529.     _XimDefaultHotKeyState,     _XimEncodeHotKetState,    _XimDecodeHotKetState},
  1530.  
  1531.     {XNPreeditAttributes,     0,
  1532.     XOffsetOf(XimDefICValues, preedit_attr),
  1533.     _XimDefaultNest,     _XimEncodeNest,    _XimDecodeNest},
  1534.  
  1535.     {XNStatusAttributes,     0,
  1536.     XOffsetOf(XimDefICValues, status_attr),
  1537.     _XimDefaultNest,     _XimEncodeNest,    _XimDecodeNest},
  1538. };
  1539.  
  1540. static XimValueOffsetInfoRec ic_pre_attr_info[] = {
  1541.     {XNArea,             0,
  1542.     XOffsetOf(ICPreeditAttributes, area),
  1543.     _XimDefaultArea,     _XimEncodeRectangle,    _XimDecodeRectangle},
  1544.  
  1545.     {XNAreaNeeded,         0,
  1546.     XOffsetOf(ICPreeditAttributes, area_needed),
  1547.     NULL,             _XimEncodeRectangle,    _XimDecodeRectangle},
  1548.  
  1549.     {XNSpotLocation,         0,
  1550.     XOffsetOf(ICPreeditAttributes, spot_location),
  1551.     NULL,             _XimEncodeSpot,    _XimDecodeSpot},
  1552.  
  1553.     {XNColormap,         0,
  1554.     XOffsetOf(ICPreeditAttributes, colormap),
  1555.     _XimDefaultColormap,     _XimEncodeColormap,    _XimDecodeColormap},
  1556.  
  1557.     {XNStdColormap,         0,
  1558.     XOffsetOf(ICPreeditAttributes, std_colormap),
  1559.     _XimDefaultStdColormap,     _XimEncodeStdColormap,    _XimDecodeStdColormap},
  1560.  
  1561.     {XNForeground,         0,
  1562.     XOffsetOf(ICPreeditAttributes, foreground),
  1563.     _XimDefaultFg,         _XimEncodeLong,    _XimDecodeLong},
  1564.  
  1565.     {XNBackground,         0,
  1566.     XOffsetOf(ICPreeditAttributes, background),
  1567.     _XimDefaultBg,         _XimEncodeLong,    _XimDecodeLong},
  1568.  
  1569.     {XNBackgroundPixmap,     0,
  1570.     XOffsetOf(ICPreeditAttributes, background_pixmap),
  1571.     _XimDefaultBgPixmap,      _XimEncodeBgPixmap,    _XimDecodeBgPixmap},
  1572.  
  1573.     {XNFontSet,             0,
  1574.     XOffsetOf(ICPreeditAttributes, fontset),
  1575.     _XimDefaultFontSet,     _XimEncodeFontSet,    _XimDecodeFontSet},
  1576.  
  1577.     {XNLineSpace,         0,
  1578.     XOffsetOf(ICPreeditAttributes, line_spacing),
  1579.     _XimDefaultLineSpace,     _XimEncodeLineSpace,    _XimDecodeLineSpace},
  1580.  
  1581.     {XNCursor,             0,
  1582.     XOffsetOf(ICPreeditAttributes, cursor),
  1583.     _XimDefaultCursor,     _XimEncodeCursor,    _XimDecodeCursor},
  1584.  
  1585.     {XNPreeditStartCallback,     0,
  1586.     XOffsetOf(ICPreeditAttributes, start_callback),
  1587.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1588.  
  1589.     {XNPreeditDoneCallback,     0,
  1590.     XOffsetOf(ICPreeditAttributes, done_callback),
  1591.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1592.  
  1593.     {XNPreeditDrawCallback,     0,
  1594.     XOffsetOf(ICPreeditAttributes, draw_callback),
  1595.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1596.  
  1597.     {XNPreeditCaretCallback,     0,
  1598.     XOffsetOf(ICPreeditAttributes, caret_callback),
  1599.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1600.  
  1601.     {XNPreeditState,         0,
  1602.     XOffsetOf(ICPreeditAttributes, preedit_state),
  1603.     _XimDefaultPreeditState, _XimEncodePreeditState,_XimDecodePreeditState},
  1604.  
  1605.     {XNPreeditStateNotifyCallback, 0,
  1606.     XOffsetOf(ICPreeditAttributes, state_notify_callback),
  1607.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1608. };
  1609.  
  1610. static XimValueOffsetInfoRec ic_sts_attr_info[] = {
  1611.     {XNArea,             0,
  1612.     XOffsetOf(ICStatusAttributes, area),
  1613.     _XimDefaultArea,     _XimEncodeRectangle,    _XimDecodeRectangle},
  1614.  
  1615.     {XNAreaNeeded,         0,
  1616.     XOffsetOf(ICStatusAttributes, area_needed),
  1617.     NULL,             _XimEncodeRectangle,    _XimDecodeRectangle},
  1618.  
  1619.     {XNColormap,         0,
  1620.     XOffsetOf(ICStatusAttributes, colormap),
  1621.     _XimDefaultColormap,     _XimEncodeColormap,    _XimDecodeColormap},
  1622.  
  1623.     {XNStdColormap,         0,
  1624.     XOffsetOf(ICStatusAttributes, std_colormap),
  1625.     _XimDefaultStdColormap,     _XimEncodeStdColormap,    _XimDecodeStdColormap},
  1626.  
  1627.     {XNForeground,         0,
  1628.     XOffsetOf(ICStatusAttributes, foreground),
  1629.     _XimDefaultFg,         _XimEncodeLong,    _XimDecodeLong},
  1630.  
  1631.     {XNBackground,         0,
  1632.     XOffsetOf(ICStatusAttributes, background),
  1633.     _XimDefaultBg,         _XimEncodeLong,    _XimDecodeLong},
  1634.  
  1635.     {XNBackgroundPixmap,     0,
  1636.     XOffsetOf(ICStatusAttributes, background_pixmap),
  1637.     _XimDefaultBgPixmap,      _XimEncodeBgPixmap,    _XimDecodeBgPixmap},
  1638.  
  1639.     {XNFontSet,             0,
  1640.     XOffsetOf(ICStatusAttributes, fontset),
  1641.     _XimDefaultFontSet,     _XimEncodeFontSet,    _XimDecodeFontSet},
  1642.  
  1643.     {XNLineSpace,         0,
  1644.     XOffsetOf(ICStatusAttributes, line_spacing),
  1645.     _XimDefaultLineSpace,     _XimEncodeLineSpace,    _XimDecodeLineSpace},
  1646.  
  1647.     {XNCursor,             0,
  1648.     XOffsetOf(ICStatusAttributes, cursor),
  1649.     _XimDefaultCursor,     _XimEncodeCursor,    _XimDecodeCursor},
  1650.  
  1651.     {XNStatusStartCallback,     0,
  1652.     XOffsetOf(ICStatusAttributes, start_callback),
  1653.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1654.  
  1655.     {XNStatusDoneCallback,     0,
  1656.     XOffsetOf(ICStatusAttributes, done_callback),
  1657.     NULL,             _XimEncodeCallback,    _XimDecodeCallback},
  1658.  
  1659.     {XNStatusDrawCallback,     0,
  1660.     XOffsetOf(ICStatusAttributes, draw_callback),
  1661.     NULL,             _XimEncodeCallback,    _XimDecodeCallback}
  1662. };
  1663.  
  1664. typedef struct _XimIMMode {
  1665.     char        *name;
  1666.     XrmQuark         quark;
  1667.     unsigned short     mode;
  1668. } XimIMMode;
  1669.  
  1670. static XimIMMode    im_mode[] = {
  1671.     {XNQueryInputStyle,        0,
  1672.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_GET)},
  1673.     {XNDestroyCallback,        0,
  1674.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_SET | XIM_MODE_IM_GET)},
  1675.     {XNResourceName,        0,
  1676.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_SET | XIM_MODE_IM_GET)},
  1677.     {XNResourceClass,        0,
  1678.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_SET | XIM_MODE_IM_GET)},
  1679.     {XNQueryIMValuesList,        0,
  1680.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_GET)},
  1681.     {XNQueryICValuesList,        0,
  1682.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_GET)},
  1683.     {XNVisiblePosition,            0,
  1684.         (XIM_MODE_IM_DEFAULT | XIM_MODE_IM_GET)}
  1685. };
  1686.  
  1687. typedef struct _XimICMode {
  1688.     char        *name;
  1689.     XrmQuark         quark;
  1690.     unsigned short     preedit_callback_mode;
  1691.     unsigned short     preedit_position_mode;
  1692.     unsigned short     preedit_area_mode;
  1693.     unsigned short     preedit_nothing_mode;
  1694.     unsigned short     preedit_none_mode;
  1695.     unsigned short     status_callback_mode;
  1696.     unsigned short     status_area_mode;
  1697.     unsigned short     status_nothing_mode;
  1698.     unsigned short     status_none_mode;
  1699. } XimICMode;
  1700.  
  1701. static XimICMode    ic_mode[] = {
  1702.     {XNInputStyle, 0,
  1703.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_GET),
  1704.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_GET),
  1705.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_GET),
  1706.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_GET),
  1707.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_GET),
  1708.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_GET),
  1709.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_GET),
  1710.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_GET),
  1711.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_GET)},
  1712.     {XNClientWindow, 0,
  1713.         (XIM_MODE_PRE_ONCE | XIM_MODE_PRE_GET),
  1714.         (XIM_MODE_PRE_ONCE | XIM_MODE_PRE_GET),
  1715.         (XIM_MODE_PRE_ONCE | XIM_MODE_PRE_GET),
  1716.         (XIM_MODE_PRE_ONCE | XIM_MODE_PRE_GET),
  1717.         0,
  1718.         (XIM_MODE_STS_ONCE | XIM_MODE_STS_GET),
  1719.         (XIM_MODE_STS_ONCE | XIM_MODE_STS_GET),
  1720.         (XIM_MODE_STS_ONCE | XIM_MODE_STS_GET),
  1721.         0},
  1722.     {XNFocusWindow, 0,
  1723.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1724.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1725.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1726.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1727.         0,
  1728.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1729.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1730.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1731.         0},
  1732.     {XNResourceName, 0,
  1733.         0,
  1734.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1735.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1736.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1737.         0,
  1738.         0,
  1739.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1740.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1741.         0},
  1742.     {XNResourceClass, 0,
  1743.         0,
  1744.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1745.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1746.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1747.         0,
  1748.         0,
  1749.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1750.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1751.         0},
  1752.     {XNGeometryCallback, 0,
  1753.         0,
  1754.         0,
  1755.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1756.         0,
  1757.         0,
  1758.         0,
  1759.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1760.         0,
  1761.         0},
  1762.     {XNFilterEvents, 0,
  1763.         XIM_MODE_PRE_GET,
  1764.         XIM_MODE_PRE_GET,
  1765.         XIM_MODE_PRE_GET,
  1766.         XIM_MODE_PRE_GET,
  1767.         0,
  1768.         XIM_MODE_STS_GET,
  1769.         XIM_MODE_STS_GET,
  1770.         XIM_MODE_STS_GET,
  1771.         XIM_MODE_STS_GET},
  1772.     {XNDestroyCallback, 0,
  1773.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1774.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1775.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1776.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1777.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1778.         0,
  1779.         0,
  1780.         0,
  1781.         0},
  1782.     {XNStringConversionCallback, 0,
  1783.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1784.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1785.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1786.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1787.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1788.         0,
  1789.         0,
  1790.         0,
  1791.         0},
  1792.     {XNStringConversion, 0,
  1793.         XIM_MODE_PRE_SET,
  1794.         XIM_MODE_PRE_SET,
  1795.         XIM_MODE_PRE_SET,
  1796.         XIM_MODE_PRE_SET,
  1797.         XIM_MODE_PRE_SET,
  1798.         0,
  1799.         0,
  1800.         0,
  1801.         0},
  1802.     {XNResetState, 0,
  1803.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1804.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1805.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1806.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1807.         0,
  1808.         0,
  1809.         0,
  1810.         0,
  1811.         0},
  1812.     {XNHotKey, 0,
  1813.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1814.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1815.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1816.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1817.         0,
  1818.         0,
  1819.         0,
  1820.         0,
  1821.         0},
  1822.     {XNHotKeyState, 0,
  1823.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1824.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1825.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1826.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1827.         0,
  1828.         0,
  1829.         0,
  1830.         0,
  1831.         0},
  1832.     {XNPreeditAttributes, 0,
  1833.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1834.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1835.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1836.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1837.         0,
  1838.         0,
  1839.         0,
  1840.         0,
  1841.         0},
  1842.     {XNStatusAttributes, 0,
  1843.         0,
  1844.         0,
  1845.         0,
  1846.         0,
  1847.         0,
  1848.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1849.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1850.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1851.         0},
  1852.     {XNArea, 0,
  1853.         0,
  1854.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1855.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1856.         0,
  1857.         0,
  1858.         0,
  1859.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1860.         0,
  1861.         0},
  1862.     {XNAreaNeeded, 0,
  1863.         0,
  1864.         0,
  1865.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1866.         0,
  1867.         0,
  1868.         0,
  1869.         (XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1870.         0,
  1871.         0},
  1872.     {XNSpotLocation, 0,
  1873.         0,
  1874.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1875.         0,
  1876.         0,
  1877.         0,
  1878.         0,
  1879.         0,
  1880.         0,
  1881.         0},
  1882.     {XNColormap, 0,
  1883.         0,
  1884.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1885.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1886.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1887.         0,
  1888.         0,
  1889.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1890.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1891.         0},
  1892.     {XNStdColormap, 0,
  1893.         0,
  1894.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1895.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1896.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1897.         0,
  1898.         0,
  1899.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1900.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1901.         0},
  1902.     {XNForeground, 0,
  1903.         0,
  1904.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1905.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1906.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1907.         0,
  1908.         0,
  1909.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1910.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1911.         0},
  1912.     {XNBackground, 0,
  1913.         0,
  1914.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1915.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1916.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1917.         0,
  1918.         0,
  1919.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1920.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1921.         0},
  1922.     {XNBackgroundPixmap, 0,
  1923.         0,
  1924.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1925.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1926.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1927.         0,
  1928.         0,
  1929.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1930.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1931.         0},
  1932.     {XNFontSet, 0,
  1933.         0,
  1934.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1935.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1936.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1937.         0,
  1938.         0,
  1939.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1940.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1941.         0},
  1942.     {XNLineSpace, 0,
  1943.         0,
  1944.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1945.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1946.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1947.         0,
  1948.         0,
  1949.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1950.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1951.         0},
  1952.     {XNCursor, 0,
  1953.         0,
  1954.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1955.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1956.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1957.         0,
  1958.         0,
  1959.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1960.         (XIM_MODE_STS_DEFAULT | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  1961.         0},
  1962.     {XNPreeditStartCallback, 0,
  1963.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1964.         0,
  1965.         0,
  1966.         0,
  1967.         0,
  1968.         0,
  1969.         0,
  1970.         0,
  1971.         0},
  1972.     {XNPreeditDoneCallback, 0,
  1973.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1974.         0,
  1975.         0,
  1976.         0,
  1977.         0,
  1978.         0,
  1979.         0,
  1980.         0,
  1981.         0},
  1982.     {XNPreeditDrawCallback, 0,
  1983.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1984.         0,
  1985.         0,
  1986.         0,
  1987.         0,
  1988.         0,
  1989.         0,
  1990.         0,
  1991.         0},
  1992.     {XNPreeditCaretCallback, 0,
  1993.         (XIM_MODE_PRE_CREATE | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  1994.         0,
  1995.         0,
  1996.         0,
  1997.         0,
  1998.         0,
  1999.         0,
  2000.         0,
  2001.         0},
  2002.     {XNPreeditState, 0,
  2003.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2004.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2005.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2006.         (XIM_MODE_PRE_DEFAULT | XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2007.         0,
  2008.         0,
  2009.         0,
  2010.         0,
  2011.         0},
  2012.     {XNPreeditStateNotifyCallback, 0,
  2013.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2014.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2015.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2016.         (XIM_MODE_PRE_SET | XIM_MODE_PRE_GET),
  2017.         0,
  2018.         0,
  2019.         0,
  2020.         0,
  2021.         0},
  2022.     {XNStatusStartCallback, 0,
  2023.         0,
  2024.         0,
  2025.         0,
  2026.         0,
  2027.         0,
  2028.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  2029.         0,
  2030.         0,
  2031.         0},
  2032.     {XNStatusDoneCallback, 0,
  2033.         0,
  2034.         0,
  2035.         0,
  2036.         0,
  2037.         0,
  2038.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  2039.         0,
  2040.         0,
  2041.         0},
  2042.     {XNStatusDrawCallback, 0,
  2043.         0,
  2044.         0,
  2045.         0,
  2046.         0,
  2047.         0,
  2048.         (XIM_MODE_STS_CREATE | XIM_MODE_STS_SET | XIM_MODE_STS_GET),
  2049.         0,
  2050.         0,
  2051.         0}
  2052. };
  2053.  
  2054. Private Bool
  2055. _XimSetResourceList(res_list, list_num, resource, num_resource, id)
  2056.     XIMResourceList     *res_list;
  2057.     unsigned int     *list_num;
  2058.     XIMResourceList      resource;
  2059.     unsigned int      num_resource;
  2060.     unsigned short      id;
  2061. {
  2062.     register int      i;
  2063.     int              len;
  2064.     XIMResourceList      res;
  2065.  
  2066.     len = sizeof(XIMResource) * num_resource;
  2067.     if(!(res = (XIMResourceList)Xmalloc(len))) {
  2068.     return False;
  2069.     }
  2070.     bzero((char *)res, len);
  2071.  
  2072.     for(i = 0; i < num_resource; i++, id++) {
  2073.     res[i]    = resource[i];
  2074.     res[i].id = id;
  2075.     }
  2076.  
  2077.     _XIMCompileResourceList(res, num_resource);
  2078.     *res_list  = res;
  2079.     *list_num  = num_resource;
  2080.     return True;
  2081. }
  2082.  
  2083. Public Bool
  2084. _XimSetIMResourceList(res_list, list_num)
  2085.     XIMResourceList    *res_list;
  2086.     unsigned int    *list_num;
  2087. {
  2088.     return _XimSetResourceList(res_list, list_num,
  2089.                 im_resources, XIMNumber(im_resources), 100);
  2090. }
  2091.  
  2092. Public Bool
  2093. _XimSetICResourceList(res_list, list_num)
  2094.     XIMResourceList    *res_list;
  2095.     unsigned int    *list_num;
  2096. {
  2097.     return _XimSetResourceList(res_list, list_num,
  2098.                 ic_resources, XIMNumber(ic_resources), 200);
  2099. }
  2100.  
  2101. Public Bool
  2102. _XimSetInnerIMResourceList(res_list, list_num)
  2103.     XIMResourceList    *res_list;
  2104.     unsigned int    *list_num;
  2105. {
  2106.     return _XimSetResourceList(res_list, list_num,
  2107.         im_inner_resources, XIMNumber(im_inner_resources), 100);
  2108. }
  2109.  
  2110. Public Bool
  2111. _XimSetInnerICResourceList(res_list, list_num)
  2112.     XIMResourceList    *res_list;
  2113.     unsigned int    *list_num;
  2114. {
  2115.     return _XimSetResourceList(res_list, list_num,
  2116.         ic_inner_resources, XIMNumber(ic_inner_resources), 200);
  2117. }
  2118.  
  2119. Private XIMResourceList
  2120. _XimGetResourceListRecByMode(res_list, list_num, mode)
  2121.     XIMResourceList     res_list;
  2122.     unsigned int     list_num;
  2123.     unsigned short     mode;
  2124. {
  2125.     register int     i;
  2126.  
  2127.     for(i = 0; i < list_num; i++) {
  2128.     if (res_list[i].mode & mode) {
  2129.         return (XIMResourceList)&res_list[i];
  2130.     }
  2131.     }
  2132.     return (XIMResourceList)NULL;
  2133. }
  2134.  
  2135. Public Bool
  2136. _XimCheckCreateICValues(res_list, list_num)
  2137.     XIMResourceList     res_list;
  2138.     unsigned int     list_num;
  2139. {
  2140.     if (!_XimGetResourceListRecByMode(res_list, list_num, XIM_MODE_IC_CREATE)) {
  2141.     return True;
  2142.     }
  2143.     return False;
  2144. }
  2145.  
  2146. Public XIMResourceList
  2147. _XimGetResourceListRecByQuark(res_list, list_num, quark)
  2148.     XIMResourceList     res_list;
  2149.     unsigned int     list_num;
  2150.     XrmQuark         quark;
  2151. {
  2152.     register int     i;
  2153.  
  2154.     for(i = 0; i < list_num; i++) {
  2155.     if (res_list[i].xrm_name == quark) {
  2156.         return (XIMResourceList)&res_list[i];
  2157.     }
  2158.     }
  2159.     return (XIMResourceList)NULL;
  2160. }
  2161.  
  2162. Public XIMResourceList
  2163. _XimGetResourceListRec(res_list, list_num, name)
  2164.     XIMResourceList     res_list;
  2165.     unsigned int     list_num;
  2166.     char        *name;
  2167. {
  2168.     XrmQuark         quark = XrmStringToQuark(name);
  2169.  
  2170.     return _XimGetResourceListRecByQuark(res_list, list_num, quark);
  2171. }
  2172.  
  2173. Public char *
  2174. _XimSetIMValueData(im, top, values, res_list, list_num)
  2175.     Xim             im;
  2176.     XPointer         top;
  2177.     XIMArg        *values;
  2178.     XIMResourceList     res_list;
  2179.     unsigned int     list_num;
  2180. {
  2181.     register XIMArg    *p;
  2182.     XIMResourceList     res;
  2183.     int             check;
  2184.  
  2185.     for(p = values; p->name != NULL; p++) {
  2186.     if(!(res = _XimGetResourceListRec(res_list, list_num, p->name))) {
  2187.         return p->value;
  2188.     }
  2189.     check = _XimCheckIMMode(res, XIM_SETIMVALUES);    
  2190.     if(check == XIM_CHECK_INVALID) {
  2191.         continue;
  2192.     } else if (check == XIM_CHECK_ERROR) {
  2193.         return p->value;
  2194.     }
  2195.         
  2196.     if(!_XimEncodeLocalIMAttr(res, top, p->value)) {
  2197.         return p->value;
  2198.     }
  2199.     }
  2200.     return NULL;
  2201. }
  2202.  
  2203. Public char *
  2204. _XimGetIMValueData(im, top, values, res_list, list_num)
  2205.     Xim             im;
  2206.     XPointer         top;
  2207.     XIMArg        *values;
  2208.     XIMResourceList     res_list;
  2209.     unsigned int     list_num;
  2210. {
  2211.     register XIMArg    *p;
  2212.     XIMResourceList     res;
  2213.     int             check;
  2214.  
  2215.     for(p = values; p->name != NULL; p++) {
  2216.     if(!(res = _XimGetResourceListRec(res_list, list_num, p->name))) {
  2217.         return p->value;
  2218.     }
  2219.     check = _XimCheckIMMode(res, XIM_GETIMVALUES);    
  2220.     if(check == XIM_CHECK_INVALID) {
  2221.         continue;
  2222.     } else if (check == XIM_CHECK_ERROR) {
  2223.         return p->value;
  2224.     }
  2225.         
  2226.     if(!_XimDecodeLocalIMAttr(res, top, p->value)) {
  2227.         return p->value;
  2228.     }
  2229.     }
  2230.     return NULL;
  2231. }
  2232.  
  2233. Public void
  2234. _XimSetIMMode(res_list, list_num)
  2235.     XIMResourceList    res_list;
  2236.     unsigned int    list_num;
  2237. {
  2238.     XIMResourceList    res;
  2239.     unsigned int    n = XIMNumber(im_mode);
  2240.     register int    i;
  2241.  
  2242.     for(i = 0; i < n; i++) {
  2243.     if(!(res = _XimGetResourceListRecByQuark(res_list,
  2244.                         list_num, im_mode[i].quark))) {
  2245.         continue;
  2246.     }
  2247.     res->mode = im_mode[i].mode;
  2248.     }
  2249.     return;
  2250. }
  2251.  
  2252. Private int
  2253. _XimCheckSetIMDefaultsMode(res)
  2254.     XIMResourceList    res;
  2255. {
  2256.     if(res->mode & XIM_MODE_IM_DEFAULT) {
  2257.     return XIM_CHECK_VALID;
  2258.     }
  2259.     return XIM_CHECK_INVALID;
  2260. }
  2261.  
  2262. Private int
  2263. _XimCheckSetIMValuesMode(res)
  2264.     XIMResourceList    res;
  2265. {
  2266.     if(res->mode & XIM_MODE_IM_SET) {
  2267.     return XIM_CHECK_VALID;
  2268.     }
  2269.     return XIM_CHECK_INVALID;
  2270. }
  2271.  
  2272. Private int
  2273.  _XimCheckGetIMValuesMode(res)
  2274.     XIMResourceList    res;
  2275. {
  2276.     if(res->mode & XIM_MODE_IM_GET) {
  2277.     return XIM_CHECK_VALID;
  2278.     }
  2279.     return XIM_CHECK_INVALID;
  2280. }
  2281.  
  2282. Public int
  2283.  _XimCheckIMMode(res, mode)
  2284.     XIMResourceList    res;
  2285.     unsigned long    mode;
  2286. {
  2287.     if(res->mode == 0) {
  2288.     return XIM_CHECK_INVALID;
  2289.     }
  2290.     if(mode & XIM_SETIMDEFAULTS) {
  2291.     return _XimCheckSetIMDefaultsMode(res);
  2292.     } else if (mode & XIM_SETIMVALUES) {
  2293.     return _XimCheckSetIMValuesMode(res);
  2294.     } else if (mode & XIM_GETIMVALUES) {
  2295.     return _XimCheckGetIMValuesMode(res);
  2296.     } else {
  2297.     return XIM_CHECK_ERROR;
  2298.     }
  2299. }
  2300.  
  2301. Public void
  2302. _XimSetICMode(res_list, list_num, style)
  2303.     XIMResourceList    res_list;
  2304.     unsigned int    list_num;
  2305.     XIMStyle        style;
  2306. {
  2307.     XIMResourceList    res;
  2308.     unsigned int    n = XIMNumber(ic_mode);
  2309.     register int    i;
  2310.     unsigned int    pre_offset;
  2311.     unsigned int    sts_offset;
  2312.  
  2313.     if(style & XIMPreeditArea) {
  2314.     pre_offset = XOffsetOf(XimICMode, preedit_area_mode);
  2315.     } else if(style & XIMPreeditCallbacks) {
  2316.     pre_offset = XOffsetOf(XimICMode, preedit_callback_mode);
  2317.     } else if(style & XIMPreeditPosition) {
  2318.     pre_offset = XOffsetOf(XimICMode, preedit_position_mode);
  2319.     } else if(style & XIMPreeditNothing) {
  2320.     pre_offset = XOffsetOf(XimICMode, preedit_nothing_mode);
  2321.     } else {
  2322.     pre_offset = XOffsetOf(XimICMode, preedit_none_mode);
  2323.     }
  2324.  
  2325.     if(style & XIMStatusArea) {
  2326.     sts_offset = XOffsetOf(XimICMode, status_area_mode);
  2327.     } else if(style & XIMStatusCallbacks) {
  2328.     sts_offset = XOffsetOf(XimICMode, status_callback_mode);
  2329.     } else if(style & XIMStatusNothing) {
  2330.     sts_offset = XOffsetOf(XimICMode, status_nothing_mode);
  2331.     } else {
  2332.     sts_offset = XOffsetOf(XimICMode, status_none_mode);
  2333.     }
  2334.  
  2335.     for(i = 0; i < n; i++) {
  2336.     if(!(res = _XimGetResourceListRecByQuark(res_list,
  2337.                         list_num, ic_mode[i].quark))) {
  2338.         continue;
  2339.     }
  2340.     res->mode = ( (*(unsigned short *)((char *)&ic_mode[i] + pre_offset))
  2341.             | (*(unsigned short *)((char *)&ic_mode[i] + sts_offset)));
  2342.     }
  2343.     return;
  2344. }
  2345.  
  2346. Private int
  2347. _XimCheckSetICDefaultsMode(res, mode)
  2348.     XIMResourceList    res;
  2349.     unsigned long    mode;
  2350. {
  2351.     if(mode & XIM_PREEDIT_ATTR) {
  2352.     if(!(res->mode & XIM_MODE_PRE_MASK)) {
  2353.         return XIM_CHECK_INVALID;
  2354.     }
  2355.  
  2356.     if(res->mode & XIM_MODE_PRE_CREATE) {
  2357.         return XIM_CHECK_ERROR;
  2358.     } else if (!(res->mode & XIM_MODE_PRE_DEFAULT)) {
  2359.         return XIM_CHECK_INVALID;
  2360.     }
  2361.  
  2362.     } else if(mode & XIM_STATUS_ATTR) {
  2363.     if(!(res->mode & XIM_MODE_STS_MASK)) {
  2364.         return XIM_CHECK_INVALID;
  2365.     }
  2366.  
  2367.     if(res->mode & XIM_MODE_STS_CREATE) {
  2368.         return XIM_CHECK_ERROR;
  2369.     }
  2370.     if(!(res->mode & XIM_MODE_STS_DEFAULT)) {
  2371.         return XIM_CHECK_INVALID;
  2372.     }
  2373.  
  2374.     } else {
  2375.     if(!res->mode) {
  2376.         return XIM_CHECK_INVALID;
  2377.     }
  2378.  
  2379.     if(res->mode & XIM_MODE_IC_CREATE) {
  2380.         return XIM_CHECK_ERROR;
  2381.     }
  2382.     if(!(res->mode & XIM_MODE_IC_DEFAULT)) {
  2383.         return XIM_CHECK_INVALID;
  2384.     }
  2385.     }
  2386.     return XIM_CHECK_VALID;
  2387. }
  2388.  
  2389. Private int
  2390. _XimCheckCreateICMode(res, mode)
  2391.     XIMResourceList    res;
  2392.     unsigned long    mode;
  2393. {
  2394.     if(mode & XIM_PREEDIT_ATTR) {
  2395.     if(!(res->mode & XIM_MODE_PRE_MASK)) {
  2396.         return XIM_CHECK_INVALID;
  2397.     }
  2398.  
  2399.     if(res->mode & XIM_MODE_PRE_CREATE) {
  2400.         res->mode &= ~XIM_MODE_PRE_CREATE;
  2401.     } else if(res->mode & XIM_MODE_PRE_ONCE) {
  2402.         res->mode &= ~XIM_MODE_PRE_ONCE;
  2403.     } else if(res->mode & XIM_MODE_PRE_DEFAULT) {
  2404.         res->mode &= ~XIM_MODE_PRE_DEFAULT;
  2405.     } else if (!(res->mode & XIM_MODE_PRE_SET)) {
  2406.         return XIM_CHECK_ERROR;
  2407.     }
  2408.  
  2409.     } else if(mode & XIM_STATUS_ATTR) {
  2410.     if(!(res->mode & XIM_MODE_STS_MASK)) {
  2411.         return  XIM_CHECK_INVALID;
  2412.     }
  2413.  
  2414.     if(res->mode & XIM_MODE_STS_CREATE) {
  2415.         res->mode &= ~XIM_MODE_STS_CREATE;
  2416.     } else if(res->mode & XIM_MODE_STS_ONCE) {
  2417.         res->mode &= ~XIM_MODE_STS_ONCE;
  2418.     } else if(res->mode & XIM_MODE_STS_DEFAULT) {
  2419.         res->mode &= ~XIM_MODE_STS_DEFAULT;
  2420.     } else if (!(res->mode & XIM_MODE_STS_SET)) {
  2421.         return XIM_CHECK_ERROR;
  2422.     }
  2423.  
  2424.     } else {
  2425.     if(!res->mode) {
  2426.         return XIM_CHECK_INVALID;
  2427.     }
  2428.  
  2429.     if(res->mode & XIM_MODE_IC_CREATE) {
  2430.         res->mode &= ~XIM_MODE_IC_CREATE;
  2431.     } else if(res->mode & XIM_MODE_IC_ONCE) {
  2432.         res->mode &= ~XIM_MODE_IC_ONCE;
  2433.     } else if(res->mode & XIM_MODE_IC_DEFAULT) {
  2434.         res->mode &= ~XIM_MODE_IC_DEFAULT;
  2435.     } else if (!(res->mode & XIM_MODE_IC_SET)) {
  2436.         return XIM_CHECK_ERROR;
  2437.     }
  2438.     }
  2439.     return XIM_CHECK_VALID;
  2440. }
  2441.  
  2442. Private int
  2443. _XimCheckSetICValuesMode(res, mode)
  2444.     XIMResourceList    res;
  2445.     unsigned long    mode;
  2446. {
  2447.     if(mode & XIM_PREEDIT_ATTR) {
  2448.     if(!(res->mode & XIM_MODE_PRE_MASK)) {
  2449.         return XIM_CHECK_INVALID;
  2450.     }
  2451.  
  2452.     if(res->mode & XIM_MODE_PRE_ONCE) {
  2453.         res->mode &= ~XIM_MODE_PRE_ONCE;
  2454.     } else if(!(res->mode & XIM_MODE_PRE_SET)) {
  2455.         return XIM_CHECK_ERROR;
  2456.     }
  2457.  
  2458.     } else if(mode & XIM_STATUS_ATTR) {
  2459.     if(!(res->mode & XIM_MODE_STS_MASK)) {
  2460.         return XIM_CHECK_INVALID;
  2461.     }
  2462.  
  2463.     if(res->mode & XIM_MODE_STS_ONCE) {
  2464.         res->mode &= ~XIM_MODE_STS_ONCE;
  2465.     } else if(!(res->mode & XIM_MODE_STS_SET)) {
  2466.         return XIM_CHECK_ERROR;
  2467.     }
  2468.     } else {
  2469.     if(!res->mode) {
  2470.         return XIM_CHECK_INVALID;
  2471.     }
  2472.     if(res->mode & XIM_MODE_IC_ONCE) {
  2473.         res->mode &= ~XIM_MODE_IC_ONCE;
  2474.     } else if(!(res->mode & XIM_MODE_IC_SET)) {
  2475.         return XIM_CHECK_ERROR;
  2476.     }
  2477.     }
  2478.     return XIM_CHECK_VALID;
  2479. }
  2480. Private int
  2481. _XimCheckGetICValuesMode(res, mode)
  2482.     XIMResourceList    res;
  2483.     unsigned long    mode;
  2484. {
  2485.     if(mode & XIM_PREEDIT_ATTR) {
  2486.     if(!(res->mode & XIM_MODE_PRE_MASK)) {
  2487.         return XIM_CHECK_INVALID;
  2488.     }
  2489.     if(!(res->mode & XIM_MODE_PRE_GET)) {
  2490.         return XIM_CHECK_ERROR;
  2491.     }
  2492.     } else if(mode & XIM_STATUS_ATTR) {
  2493.     if(!(res->mode & XIM_MODE_STS_MASK)) {
  2494.         return XIM_CHECK_INVALID;
  2495.     }
  2496.     if(!(res->mode & XIM_MODE_STS_GET)) {
  2497.         return XIM_CHECK_ERROR;
  2498.     }
  2499.     } else {
  2500.     if(!res->mode) {
  2501.         return XIM_CHECK_INVALID;
  2502.     }
  2503.     if(!(res->mode & XIM_MODE_IC_GET)) {
  2504.         return XIM_CHECK_ERROR;
  2505.     }
  2506.     }
  2507.     return XIM_CHECK_VALID;
  2508. }
  2509. Public int
  2510.  _XimCheckICMode(res, mode)
  2511.     XIMResourceList    res;
  2512.     unsigned long     mode;
  2513. {
  2514.     if(mode &XIM_SETICDEFAULTS) {
  2515.     return _XimCheckSetICDefaultsMode(res, mode);
  2516.     } else if (mode & XIM_CREATEIC) {
  2517.     return _XimCheckCreateICMode(res, mode);
  2518.     } else if (mode & XIM_SETICVALUES) {
  2519.     return _XimCheckSetICValuesMode(res, mode);
  2520.     } else if (mode & XIM_GETICVALUES) {
  2521.     return _XimCheckGetICValuesMode(res, mode);
  2522.     } else {
  2523.     return XIM_CHECK_ERROR;
  2524.     }
  2525. }
  2526. Public Bool
  2527. _XimSetLocalIMDefaults(im, top, res_list, list_num)
  2528.     Xim             im;
  2529.     XPointer         top;
  2530.     XIMResourceList     res_list;
  2531.     unsigned int     list_num;
  2532. {
  2533.     XimValueOffsetInfo     info;
  2534.     unsigned int     num;
  2535.     register int     i;
  2536.     XIMResourceList     res;
  2537.     int             check;
  2538.     info = im_attr_info;
  2539.     num  = XIMNumber(im_attr_info);
  2540.     for(i = 0; i < num; i++) {
  2541.     if((res = _XimGetResourceListRecByQuark( res_list, list_num,
  2542.                 info[i].quark)) == (XIMResourceList)NULL) { 
  2543.         return False;
  2544.     }
  2545.     check = _XimCheckIMMode(res, XIM_SETIMDEFAULTS);
  2546.     if(check == XIM_CHECK_INVALID) {
  2547.         continue;
  2548.     } else if (check == XIM_CHECK_ERROR) {
  2549.         return False;
  2550.     }
  2551.     if(!info[i].defaults) {
  2552.         continue;
  2553.     }
  2554.     if(!(info[i].defaults(&info[i], top, (XPointer)NULL, 0))) {
  2555.         return False;
  2556.     }
  2557.     }
  2558.     return True;
  2559. }
  2560. Public Bool
  2561. _XimSetICDefaults(ic, top, mode, res_list, list_num)
  2562.     Xic             ic;
  2563.     XPointer         top;
  2564.     unsigned long     mode;
  2565.     XIMResourceList     res_list;
  2566.     unsigned int     list_num;
  2567. {
  2568.     unsigned int     num;
  2569.     XimValueOffsetInfo     info;
  2570.     register int     i;
  2571.     XIMResourceList     res;
  2572.     int             check;
  2573.     XrmQuark         pre_quark;
  2574.     XrmQuark         sts_quark;
  2575.     pre_quark = XrmStringToQuark(XNPreeditAttributes);
  2576.     sts_quark = XrmStringToQuark(XNStatusAttributes);
  2577.     if(mode & XIM_PREEDIT_ATTR) {
  2578.     info = ic_pre_attr_info;
  2579.     num  = XIMNumber(ic_pre_attr_info);
  2580.     } else if(mode & XIM_STATUS_ATTR) {
  2581.     info = ic_sts_attr_info;
  2582.     num  = XIMNumber(ic_sts_attr_info);
  2583.     } else {
  2584.     info = ic_attr_info;
  2585.     num  = XIMNumber(ic_attr_info);
  2586.     }
  2587.     for(i = 0; i < num; i++) {
  2588.     if(info[i].quark == pre_quark) {
  2589.         if(!_XimSetICDefaults(ic, (XPointer)((char *)top + info[i].offset),
  2590.             (mode | XIM_PREEDIT_ATTR), res_list, list_num)) {
  2591.         return False;
  2592.         }
  2593.     } else if (info[i].quark == sts_quark) {
  2594.         if(!_XimSetICDefaults(ic, (XPointer)((char *)top + info[i].offset),
  2595.             (mode | XIM_STATUS_ATTR), res_list, list_num)) {
  2596.         return False;
  2597.         }
  2598.     } else {
  2599.         if(!(res = _XimGetResourceListRecByQuark(res_list, list_num,
  2600.                             info[i].quark))) {
  2601.         return False;
  2602.         }
  2603.         check = _XimCheckICMode(res, mode);
  2604.         if (check == XIM_CHECK_INVALID) {
  2605.         continue;
  2606.         } else if (check == XIM_CHECK_ERROR) {
  2607.         return False;
  2608.         }
  2609.         if (!info[i].defaults) {
  2610.         continue;
  2611.         }
  2612.         if (!(info[i].defaults(&info[i], top, (XPointer)ic, mode))) {
  2613.         return False;
  2614.         }
  2615.     }
  2616.     }
  2617.     return True;
  2618. }
  2619. Private Bool
  2620. _XimEncodeAttr(info, num, res, top, val)
  2621.     XimValueOffsetInfo     info;
  2622.     unsigned int     num;
  2623.     XIMResourceList     res;
  2624.     XPointer         top;
  2625.     XPointer         val;
  2626. {
  2627.     register int     i;
  2628.     for(i = 0; i < num; i++ ) {
  2629.     if(info[i].quark == res->xrm_name) {
  2630.         if(!info[i].encode) {
  2631.         return False;
  2632.         }
  2633.         return (*info[i].encode)(&info[i], top, val);
  2634.     }
  2635.     }
  2636.     return False;
  2637. }
  2638. Public Bool
  2639. _XimEncodeLocalIMAttr(res, top, val)
  2640.     XIMResourceList     res;
  2641.     XPointer         top;
  2642.     XPointer         val;
  2643. {
  2644.     return _XimEncodeAttr(im_attr_info, XIMNumber(im_attr_info),
  2645.                     res, top, val);
  2646. }
  2647. Public Bool
  2648. _XimEncodeLocalICAttr(ic, res, top, arg, mode)
  2649.     Xic             ic;
  2650.     XIMResourceList     res;
  2651.     XPointer         top;
  2652.     XIMArg        *arg;
  2653.     unsigned long     mode;
  2654. {
  2655.     unsigned int     num;
  2656.     XimValueOffsetInfo     info;
  2657.     if(mode & XIM_PREEDIT_ATTR) {
  2658.     info = ic_pre_attr_info;
  2659.     num  = XIMNumber(ic_pre_attr_info);
  2660.     } else if(mode & XIM_STATUS_ATTR) {
  2661.     info = ic_sts_attr_info;
  2662.     num  = XIMNumber(ic_sts_attr_info);
  2663.     } else {
  2664.     info = ic_attr_info;
  2665.     num  = XIMNumber(ic_attr_info);
  2666.     }
  2667.     return _XimEncodeAttr(info, num, res, top, arg->value);
  2668. }
  2669. Private Bool
  2670. _XimEncodeLocalTopValue(ic, res, val, flag)
  2671.     Xic             ic;
  2672.     XIMResourceList     res;
  2673.     XPointer         val;
  2674.     Bool         flag;
  2675. {
  2676.     XIMArg        *p = (XIMArg *)val;
  2677.     if (res->xrm_name == XrmStringToQuark(XNClientWindow)) {
  2678.     ic->core.client_window = (Window)p->value;
  2679.     if (ic->core.focus_window == (Window)0)
  2680.         ic->core.focus_window = ic->core.client_window;
  2681.     if (flag) {
  2682.         _XRegisterFilterByType(ic->core.im->core.display,
  2683.             ic->core.focus_window,
  2684.             KeyPress, KeyPress, _XimLocalFilter, (XPointer)ic);
  2685.     }
  2686.     } else if (res->xrm_name == XrmStringToQuark(XNFocusWindow)) {
  2687.     if (ic->core.client_window) {
  2688.         if (flag) {
  2689.             _XUnregisterFilter(ic->core.im->core.display,
  2690.             ic->core.focus_window, _XimLocalFilter, (XPointer)ic);
  2691.         }
  2692.         ic->core.focus_window = (Window)p->value;
  2693.         if (flag) {
  2694.             _XRegisterFilterByType(ic->core.im->core.display,
  2695.             ic->core.focus_window, KeyPress, KeyPress,
  2696.             _XimLocalFilter, (XPointer)ic);
  2697.         }
  2698.     } else
  2699.         ic->core.focus_window = (Window)p->value;
  2700.     }
  2701.     return True;
  2702. }
  2703. Private Bool
  2704. _XimEncodeLocalPreeditValue(ic, res, val)
  2705.     Xic             ic;
  2706.     XIMResourceList     res;
  2707.     XPointer         val;
  2708. {
  2709.     XIMArg        *p = (XIMArg *)val;
  2710.     if (res->xrm_name == XrmStringToQuark(XNStdColormap)) {
  2711.     XStandardColormap    *colormap_ret;
  2712.     int             count;
  2713.     if (!(XGetRGBColormaps(ic->core.im->core.display,
  2714.                 ic->core.focus_window, &colormap_ret,
  2715.                 &count, (Atom)p->value)))
  2716.         return False;
  2717.     }
  2718.     return True;
  2719. }
  2720. Private Bool
  2721. _XimEncodeLocalStatusValue(ic, res, val)
  2722.     Xic             ic;
  2723.     XIMResourceList     res;
  2724.     XPointer         val;
  2725. {
  2726.     XIMArg        *p = (XIMArg *)val;
  2727.     if (res->xrm_name == XrmStringToQuark(XNStdColormap)) {
  2728.     XStandardColormap    *colormap_ret;
  2729.     int             count;
  2730.     if (!(XGetRGBColormaps(ic->core.im->core.display,
  2731.                 ic->core.focus_window, &colormap_ret,
  2732.                 &count, (Atom)p->value)))
  2733.         return False;
  2734.     }
  2735.     return True;
  2736. }
  2737. Public char *
  2738. _XimSetICValueData(ic, top, res_list, list_num, values, mode, flag)
  2739.     Xic             ic;
  2740.     XPointer         top;
  2741.     XIMResourceList     res_list;
  2742.     unsigned int     list_num;
  2743.     XIMArg        *values;
  2744.     unsigned long     mode;
  2745.     Bool         flag;
  2746. {
  2747.     register  XIMArg    *p;
  2748.     XIMResourceList     res;
  2749.     char        *name;
  2750.     int             check;
  2751.     XrmQuark         pre_quark;
  2752.     XrmQuark         sts_quark;
  2753.     pre_quark = XrmStringToQuark(XNPreeditAttributes);
  2754.     sts_quark = XrmStringToQuark(XNStatusAttributes);
  2755.     for(p = values; p->name != NULL; p++) {
  2756.     if((res = _XimGetResourceListRec(res_list, list_num,
  2757.                     p->name)) == (XIMResourceList)NULL) {
  2758.         return p->name;
  2759.     }
  2760.     if(res->xrm_name == pre_quark) {
  2761.         if(name = _XimSetICValueData(ic,
  2762.             (XPointer)(&((XimDefICValues *)top)->preedit_attr),
  2763.             res_list, list_num, (XIMArg *)p->value,
  2764.             (mode | XIM_PREEDIT_ATTR), flag)) {
  2765.         return name;
  2766.         }
  2767.     } else if(res->xrm_name == sts_quark) {
  2768.         if(name = _XimSetICValueData(ic,
  2769.             (XPointer)(&((XimDefICValues *)top)->status_attr),
  2770.             res_list, list_num, (XIMArg *)p->value,
  2771.             (mode | XIM_STATUS_ATTR), flag)) {
  2772.         return name;
  2773.         }
  2774.     } else {
  2775.         check = _XimCheckICMode(res, mode);
  2776.         if(check == XIM_CHECK_INVALID) {
  2777.         continue;
  2778.         } else if(check == XIM_CHECK_ERROR) {
  2779.         return p->name;
  2780.         }
  2781.         if(mode & XIM_PREEDIT_ATTR) {
  2782.         if (!_XimEncodeLocalPreeditValue(ic, res, (XPointer)p))
  2783.                 return False;
  2784.             } else if(mode & XIM_STATUS_ATTR) {
  2785.         if (!_XimEncodeLocalStatusValue(ic, res, (XPointer)p))
  2786.                 return False;
  2787.             } else {
  2788.         if (!_XimEncodeLocalTopValue(ic, res, (XPointer)p, flag))
  2789.                 return False;
  2790.             }
  2791.         if(_XimEncodeLocalICAttr(ic, res, top, p, mode) == False) {
  2792.         return p->name;
  2793.         }
  2794.     }
  2795.     }
  2796.     return NULL;
  2797. }
  2798. Private Bool
  2799. _XimCheckInputStyle(styles, style)
  2800.     XIMStyles        *styles;
  2801.     XIMStyle         style;
  2802. {
  2803.     int             num = styles->count_styles;
  2804.     register int     i;
  2805.     for(i = 0; i < num; i++) {
  2806.     if(styles->supported_styles[i] == style) {
  2807.         return True;
  2808.     }
  2809.     }
  2810.     return False;
  2811. }
  2812. Public Bool
  2813. _XimCheckLocalInputStyle(ic, top, values, styles, res_list, list_num)
  2814.     Xic             ic;
  2815.     XPointer         top;
  2816.     XIMArg        *values;
  2817.     XIMStyles        *styles;
  2818.     XIMResourceList     res_list;
  2819.     unsigned int     list_num;
  2820. {
  2821.     XrmQuark         quark = XrmStringToQuark(XNInputStyle);
  2822.     register XIMArg    *p;
  2823.     XIMResourceList     res;
  2824.     for(p = values; p && p->name != NULL; p++) {
  2825.     if(quark == XrmStringToQuark(p->name)) {
  2826.         if(!(res = _XimGetResourceListRec(res_list, list_num, p->name))) {
  2827.         return False;
  2828.         }
  2829.         if(!_XimEncodeLocalICAttr(ic, res, top, p, 0)) {
  2830.         return False;
  2831.         }
  2832.         if (_XimCheckInputStyle(styles,
  2833.             ((XimDefICValues *)top)->input_style)) {
  2834.         return True;
  2835.         }
  2836.         return False;
  2837.     }
  2838.     }
  2839.     return False;
  2840. }
  2841. Private Bool
  2842. _XimDecodeAttr(info, num, res, top, val)
  2843.     XimValueOffsetInfo     info;
  2844.     unsigned int     num;
  2845.     XIMResourceList     res;
  2846.     XPointer         top;
  2847.     XPointer         val;
  2848. {
  2849.     register int     i;
  2850.     for(i = 0; i < num; i++ ) {
  2851.     if(info[i].quark == res->xrm_name) {
  2852.         if(!info[i].decode) {
  2853.         return False;
  2854.         }
  2855.         return (*info[i].decode)(&info[i], top, val); 
  2856.     }
  2857.     }
  2858.     return False;
  2859. }
  2860. Public Bool
  2861. _XimDecodeLocalIMAttr(res, top, val)
  2862.     XIMResourceList     res;
  2863.     XPointer         top;
  2864.     XPointer         val;
  2865. {
  2866.     return _XimDecodeAttr(im_attr_info, XIMNumber(im_attr_info),
  2867.                     res, top, val);
  2868. }
  2869. Public Bool
  2870. _XimDecodeLocalICAttr(res, top, val, mode)
  2871.     XIMResourceList     res;
  2872.     XPointer         top;
  2873.     XPointer         val;
  2874.     unsigned long     mode;
  2875. {
  2876.     unsigned int     num;
  2877.     XimValueOffsetInfo     info;
  2878.     if(mode & XIM_PREEDIT_ATTR) {
  2879.     info = ic_pre_attr_info;
  2880.     num  = XIMNumber(ic_pre_attr_info);
  2881.     top = (XPointer) &((XimDefICValues *)top)->preedit_attr;
  2882.     } else if(mode & XIM_STATUS_ATTR) {
  2883.     info = ic_sts_attr_info;
  2884.     num  = XIMNumber(ic_sts_attr_info);
  2885.     top = (XPointer) &((XimDefICValues *)top)->status_attr;
  2886.     } else {
  2887.     info = ic_attr_info;
  2888.     num  = XIMNumber(ic_attr_info);
  2889.     }
  2890.     return _XimDecodeAttr(info, num, res, top, val);
  2891. }
  2892. Public char *
  2893. _XimGetICValueData(ic, top, res_list, list_num, values, mode)
  2894.     Xic             ic;
  2895.     XPointer         top;
  2896.     XIMResourceList     res_list;
  2897.     unsigned int     list_num;
  2898.     XIMArg        *values;
  2899.     unsigned long     mode;
  2900. {
  2901.     register  XIMArg    *p;
  2902.     XIMResourceList     res;
  2903.     char        *name;
  2904.     int             check;
  2905.     XrmQuark         pre_quark;
  2906.     XrmQuark         sts_quark;
  2907.     pre_quark = XrmStringToQuark(XNPreeditAttributes);
  2908.     sts_quark = XrmStringToQuark(XNStatusAttributes);
  2909.     for(p = values; p->name != NULL; p++) {
  2910.     if((res = _XimGetResourceListRec(res_list, list_num,
  2911.                     p->name)) == (XIMResourceList)NULL) {
  2912.         return p->name;
  2913.     }
  2914.     if(res->xrm_name == pre_quark) {
  2915.         if(name = _XimGetICValueData(ic,
  2916.             (XPointer)(&((XimDefICValues *)top)->preedit_attr),
  2917.             res_list, list_num, (XIMArg *)p->value,
  2918.             (mode | XIM_PREEDIT_ATTR))) {
  2919.         return name;
  2920.         }
  2921.     } else if(res->xrm_name == sts_quark) {
  2922.         if(name = _XimGetICValueData(ic,
  2923.             (XPointer)(&((XimDefICValues *)top)->status_attr),
  2924.             res_list, list_num, (XIMArg *)p->value,
  2925.             (mode | XIM_STATUS_ATTR))) {
  2926.         return name;
  2927.         }
  2928.     } else {
  2929.         check = _XimCheckICMode(res, mode);
  2930.         if(check == XIM_CHECK_INVALID) {
  2931.         continue;
  2932.         } else if(check == XIM_CHECK_ERROR) {
  2933.         return p->name;
  2934.         }
  2935.         if(_XimDecodeLocalICAttr(res, top, p->value, mode) == False) {
  2936.         return p->name;
  2937.         }
  2938.     }
  2939.     }
  2940.     return NULL;
  2941. }
  2942. Public void
  2943. _XimGetCurrentIMValues(im, im_values)
  2944.     Xim             im;
  2945.     XimDefIMValues    *im_values;
  2946. {
  2947.     bzero((char *)im_values, sizeof(XimDefIMValues));
  2948.     im_values->styles        = im->core.styles;
  2949.     im_values->im_values_list    = im->core.im_values_list;
  2950.     im_values->ic_values_list    = im->core.ic_values_list;
  2951.     im_values->destroy_callback = im->core.destroy_callback;
  2952.     im_values->res_name        = im->core.res_name;
  2953.     im_values->res_class    = im->core.res_class;
  2954.     im_values->visible_position    = im->core.visible_position;
  2955. }
  2956. Public void
  2957. _XimSetCurrentIMValues(im, im_values)
  2958.     Xim             im;
  2959.     XimDefIMValues    *im_values;
  2960. {
  2961.     im->core.styles        = im_values->styles;
  2962.     im->core.im_values_list    = im_values->im_values_list;
  2963.     im->core.ic_values_list    = im_values->ic_values_list;
  2964.     im->core.destroy_callback    = im_values->destroy_callback;
  2965.     im->core.res_name        = im_values->res_name;
  2966.     im->core.res_class        = im_values->res_class;
  2967.     im->core.visible_position    = im_values->visible_position;
  2968. }
  2969. Public void
  2970. _XimGetCurrentICValues(ic, ic_values)
  2971.     Xic             ic;
  2972.     XimDefICValues    *ic_values;
  2973. {
  2974.     bzero((char *)ic_values, sizeof(XimDefICValues));
  2975.     ic_values->input_style     = ic->core.input_style;
  2976.     ic_values->client_window     = ic->core.client_window;
  2977.     ic_values->focus_window     = ic->core.focus_window;
  2978.     ic_values->filter_events     = ic->core.filter_events;
  2979.     ic_values->geometry_callback = ic->core.geometry_callback;
  2980.     ic_values->res_name         = ic->core.res_name;
  2981.     ic_values->res_class     = ic->core.res_class;
  2982.     ic_values->destroy_callback     = ic->core.destroy_callback;
  2983.     ic_values->string_conversion_callback
  2984.                  = ic->core.string_conversion_callback;
  2985.     ic_values->string_conversion = ic->core.string_conversion;
  2986.     ic_values->reset_state     = ic->core.reset_state;
  2987.     ic_values->hotkey         = ic->core.hotkey;
  2988.     ic_values->hotkey_state     = ic->core.hotkey_state;
  2989.     ic_values->preedit_attr     = ic->core.preedit_attr;
  2990.     ic_values->status_attr     = ic->core.status_attr;
  2991. }
  2992. Public void
  2993. _XimSetCurrentICValues(ic, ic_values)
  2994.     Xic             ic;
  2995.     XimDefICValues    *ic_values;
  2996. {
  2997.     ic->core.input_style    = ic_values->input_style;
  2998.     ic->core.client_window    = ic_values->client_window;
  2999.     if (ic_values->focus_window)
  3000.     ic->core.focus_window    = ic_values->focus_window;
  3001.     ic->core.filter_events    = ic_values->filter_events;
  3002.     ic->core.geometry_callback    = ic_values->geometry_callback;
  3003.     ic->core.res_name        = ic_values->res_name;
  3004.     ic->core.res_class        = ic_values->res_class;
  3005.     ic->core.destroy_callback     = ic_values->destroy_callback;
  3006.     ic->core.string_conversion_callback
  3007.                 = ic_values->string_conversion_callback;
  3008.     ic->core.string_conversion    = ic_values->string_conversion;
  3009.     ic->core.reset_state    = ic_values->reset_state;
  3010.     ic->core.hotkey        = ic_values->hotkey;
  3011.     ic->core.hotkey_state    = ic_values->hotkey_state;
  3012.     ic->core.preedit_attr    = ic_values->preedit_attr;
  3013.     ic->core.status_attr    = ic_values->status_attr;
  3014. }
  3015. Private void
  3016. _XimInitialIMOffsetInfo()
  3017. {
  3018.     unsigned int     n = XIMNumber(im_attr_info);
  3019.     register int     i;
  3020.     for(i = 0; i < n; i++) {
  3021.     im_attr_info[i].quark = XrmStringToQuark(im_attr_info[i].name);
  3022.     }
  3023. }
  3024. Private void
  3025. _XimInitialICOffsetInfo()
  3026. {
  3027.     unsigned int     n;
  3028.     register int     i;
  3029.     n = XIMNumber(ic_attr_info);
  3030.     for(i = 0; i < n; i++) {
  3031.     ic_attr_info[i].quark = XrmStringToQuark(ic_attr_info[i].name);
  3032.     }
  3033.     n = XIMNumber(ic_pre_attr_info);
  3034.     for(i = 0; i < n; i++) {
  3035.     ic_pre_attr_info[i].quark = XrmStringToQuark(ic_pre_attr_info[i].name);
  3036.     }
  3037.     n = XIMNumber(ic_sts_attr_info);
  3038.     for(i = 0; i < n; i++) {
  3039.     ic_sts_attr_info[i].quark = XrmStringToQuark(ic_sts_attr_info[i].name);
  3040.     }
  3041. }
  3042. Private void
  3043. _XimInitialIMMode()
  3044. {
  3045.     unsigned int    n = XIMNumber(im_mode);
  3046.     register int    i;
  3047.     for(i = 0; i < n; i++) {
  3048.     im_mode[i].quark = XrmStringToQuark(im_mode[i].name);
  3049.     }
  3050. }
  3051. Private void
  3052. _XimInitialICMode()
  3053. {
  3054.     unsigned int    n = XIMNumber(ic_mode);
  3055.     register int    i;
  3056.     for(i = 0; i < n; i++) {
  3057.     ic_mode[i].quark = XrmStringToQuark(ic_mode[i].name);
  3058.     }
  3059. }
  3060. Public void
  3061. _XimInitialResourceInfo()
  3062. {
  3063.     static Bool    init_flag = False;
  3064.     if(init_flag == True) {
  3065.     return;
  3066.     }
  3067.     _XimInitialIMOffsetInfo();
  3068.     _XimInitialICOffsetInfo();
  3069.     _XimInitialIMMode();
  3070.     _XimInitialICMode();
  3071.     init_flag = True;
  3072. }
  3073.