home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xom_Generic.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  53KB  |  2,028 lines
  1. /* $TOG: omGeneric.c /main/22 1997/07/17 21:49:06 kaleb $ */
  2. /*
  3.  * Copyright 1992, 1993 by TOSHIBA Corp.
  4.  *
  5.  * Permission to use, copy, modify, and distribute this software and its
  6.  * documentation for any purpose and without fee is hereby granted, provided
  7.  * that the above copyright notice appear in all copies and that both that
  8.  * copyright notice and this permission notice appear in supporting
  9.  * documentation, and that the name of TOSHIBA not be used in advertising
  10.  * or publicity pertaining to distribution of the software without specific,
  11.  * written prior permission. TOSHIBA make no representations about the
  12.  * suitability of this software for any purpose.  It is provided "as is"
  13.  * without express or implied warranty.
  14.  *
  15.  * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17.  * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21.  * SOFTWARE.
  22.  *
  23.  * Author: Katsuhisa Yano    TOSHIBA Corp.
  24.  *                   mopi@osa.ilab.toshiba.co.jp
  25.  */
  26. /*
  27.  * Copyright 1995 by FUJITSU LIMITED
  28.  * This is source code modified by FUJITSU LIMITED under the Joint
  29.  * Development Agreement for the CDE/Motif PST.
  30.  *
  31.  * Modifier: Takanori Tateno   FUJITSU LIMITED
  32.  *
  33.  */
  34. /* $XFree86: xc/lib/X11/omGeneric.c,v 3.5.2.7 1998/05/19 14:36:46 dawes Exp $ */
  35.  
  36. #include "Xlib_private.h"
  37. #include "XomGeneric.h"
  38. #include <X11/Xos.h>
  39. #include <X11/Xatom.h>
  40. #include <stdio.h>
  41. #include <string.h>
  42. #include <ctype.h>
  43.  
  44. #define MAXFONTS        100
  45. #define    PIXEL_SIZE_FIELD     7
  46. #define    POINT_SIZE_FIELD     8
  47. #define    CHARSET_ENCODING_FIELD    14
  48. #ifndef    BUFSIZE
  49. #define    BUFSIZE    2048
  50. #endif
  51.  
  52. extern int _XmbDefaultTextEscapement(), _XwcDefaultTextEscapement();
  53. extern int _XmbDefaultTextExtents(), _XwcDefaultTextExtents();
  54. extern Status _XmbDefaultTextPerCharExtents(), _XwcDefaultTextPerCharExtents();
  55. extern int _XmbDefaultDrawString(), _XwcDefaultDrawString();
  56. extern void _XmbDefaultDrawImageString(), _XwcDefaultDrawImageString();
  57.  
  58. extern int _XmbGenericTextEscapement(), _XwcGenericTextEscapement();
  59. extern int _XmbGenericTextExtents(), _XwcGenericTextExtents();
  60. extern Status _XmbGenericTextPerCharExtents(), _XwcGenericTextPerCharExtents();
  61. extern int _XmbGenericDrawString(), _XwcGenericDrawString();
  62. extern void _XmbGenericDrawImageString(), _XwcGenericDrawImageString();
  63.  
  64. extern void _XlcDbg_printValue();
  65.  
  66. /* For VW/UDC start */
  67.  
  68. static FontData
  69. init_fontdata(font_data, font_data_count)
  70.     FontData    font_data;
  71.     int        font_data_count;
  72. {
  73.     DBUG_ENTER("init_fontdata")
  74.     FontData    fd;
  75.     int        i;
  76.  
  77.     fd = (FontData)Xmalloc(sizeof(FontDataRec) * font_data_count);
  78.     if(fd == (FontData) NULL)
  79.     DBUG_RETURN(False);
  80.  
  81.     memset(fd, 0x00, sizeof(FontData) * font_data_count);
  82.     for(i = 0 ; i < font_data_count ; i++)
  83.     fd[i] = font_data[i];
  84.  
  85.     DBUG_RETURN(fd);
  86. }
  87.  
  88. static VRotate
  89. init_vrotate(font_data, font_data_count, type, code_range, code_range_num)
  90.     FontData    font_data;
  91.     int        font_data_count;
  92.     int        type;
  93.     CodeRange    code_range;
  94.     int        code_range_num;
  95. {
  96.     DBUG_ENTER("init_vrotate")
  97.     VRotate    vrotate;
  98.     int        i;
  99.  
  100.     if(type == VROTATE_NONE)
  101.     DBUG_RETURN((VRotate)NULL);
  102.  
  103.     vrotate = (VRotate)Xmalloc(sizeof(VRotateRec) * font_data_count);
  104.     if(vrotate == (VRotate) NULL)
  105.     DBUG_RETURN(False);
  106.  
  107.     memset(vrotate, 0x00, sizeof(VRotateRec) * font_data_count);
  108.     for(i = 0 ; i < font_data_count ; i++) {
  109.     vrotate[i].charset_name = font_data[i].name;
  110.     vrotate[i].side = font_data[i].side;
  111.     if(type == VROTATE_PART) {
  112.         vrotate[i].num_cr = code_range_num;
  113.         vrotate[i].code_range = code_range;
  114.     }
  115.     }
  116.  
  117.     DBUG_RETURN(vrotate);
  118. }
  119.  
  120. static Bool
  121. init_fontset(oc)
  122.     XOC oc;
  123. {
  124.     DBUG_ENTER("init_fontset")
  125.     XOCGenericPart *gen;
  126.     FontSet font_set;
  127.     OMData data;
  128.     int count;
  129.  
  130.     count = XOM_GENERIC(oc->core.om)->data_num;
  131.     data = XOM_GENERIC(oc->core.om)->data;
  132.  
  133.     font_set = (FontSet) Xmalloc(sizeof(FontSetRec) * count);
  134.     if (font_set == NULL)
  135.     DBUG_RETURN(False);
  136.     memset((char *) font_set, 0x00, sizeof(FontSetRec) * count);
  137.  
  138.     gen = XOC_GENERIC(oc);
  139.     gen->font_set_num = count;
  140.     gen->font_set = font_set;
  141.  
  142.     for ( ; count-- > 0; data++, font_set++) {
  143.     font_set->charset_count = data->charset_count;
  144.     font_set->charset_list = data->charset_list;
  145.  
  146.     if((font_set->font_data = init_fontdata(data->font_data,
  147.                   data->font_data_count)) == NULL)
  148.         goto err;
  149.     font_set->font_data_count = data->font_data_count;
  150.     if((font_set->substitute = init_fontdata(data->substitute,
  151.                    data->substitute_num)) == NULL)
  152.         goto err;
  153.     font_set->substitute_num = data->substitute_num;
  154.     if((font_set->vmap = init_fontdata(data->vmap,
  155.                  data->vmap_num)) == NULL)
  156.         goto err;
  157.     font_set->vmap_num       = data->vmap_num;
  158.  
  159.     if(data->vrotate_type != VROTATE_NONE) {
  160.         /* A vrotate member is specified primary font data */
  161.         /* as initial value.                               */
  162.         if((font_set->vrotate = init_vrotate(data->font_data,
  163.                          data->font_data_count,
  164.                          data->vrotate_type,
  165.                          data->vrotate,
  166.                          data->vrotate_num)) == NULL)
  167.         goto err;
  168.         font_set->vrotate_num = data->font_data_count;
  169.     }
  170.     }
  171.     DBUG_RETURN(True);
  172.  
  173. err:
  174.     if(font_set->font_data)
  175.     Xfree(font_set->font_data);
  176.     if(font_set->substitute)
  177.     Xfree(font_set->substitute);
  178.     if(font_set->vmap)
  179.     Xfree(font_set->vmap);
  180.     if(font_set->vrotate)
  181.     Xfree(font_set->vrotate);
  182.     if(font_set)
  183.     Xfree(font_set);
  184.     gen->font_set = (FontSet) NULL;
  185.     gen->font_set_num = 0;
  186.     DBUG_RETURN(False);
  187. }
  188.  
  189. /* For VW/UDC end */
  190.  
  191. static char *
  192. get_prop_name(dpy, fs)
  193.     Display *dpy;
  194.     XFontStruct    *fs;
  195. {
  196.     DBUG_ENTER("get_prop_name")
  197.     unsigned long fp;
  198.  
  199.     if (XGetFontProperty(fs, XA_FONT, &fp)) {
  200.     char *result = XGetAtomName(dpy, fp); 
  201.     DBUG_RETURN(result);
  202.     }
  203.  
  204.     DBUG_RETURN((char *) NULL);
  205. }
  206.  
  207. /* For VW/UDC start */
  208.  
  209. static Bool
  210. load_fontdata(oc, font_data, font_data_num)
  211.     XOC        oc;
  212.     FontData    font_data;
  213.     int        font_data_num;
  214. {
  215.     DBUG_ENTER("load_fontdata")
  216.     Display    *dpy = oc->core.om->core.display;
  217.     FontData    fd = font_data;
  218.  
  219.     if(font_data == NULL) return(True);
  220.     for( ; font_data_num-- ; fd++) {
  221.     if(fd->xlfd_name != (char *) NULL && fd->font == NULL) {
  222.         fd->font = XLoadQueryFont(dpy, fd->xlfd_name);
  223.         if (fd->font == NULL){
  224.         DBUG_RETURN(False);
  225.         }
  226.     }
  227.     }
  228.     DBUG_RETURN(True);
  229. }
  230.  
  231. static Bool
  232. load_font(oc)
  233.     XOC oc;
  234. {
  235.     DBUG_ENTER("load_font")
  236.     int i;
  237.     XOCGenericPart *gen = XOC_GENERIC(oc);
  238.     FontSet font_set = gen->font_set;
  239.     int num = gen->font_set_num;
  240.  
  241.     for ( ; num-- > 0; font_set++) {
  242.     if (font_set->font_name == NULL)
  243.         continue;
  244.  
  245.     if(load_fontdata(oc, font_set->font_data,
  246.              font_set->font_data_count) != True)
  247.         DBUG_RETURN(False);
  248.  
  249.     if(load_fontdata(oc, font_set->substitute,
  250.              font_set->substitute_num) != True)
  251.         DBUG_RETURN(False);
  252.  
  253.     if(font_set->font_data_count > 0 && font_set->font_data->font) {
  254.         font_set->font = font_set->font_data->font;
  255.     } else if(font_set->substitute_num > 0 ) {
  256.         for(i=0;i<font_set->substitute_num;i++){
  257.         if(font_set->substitute[i].font != NULL){
  258.             font_set->font = font_set->substitute[i].font;
  259.             break ;
  260.         }
  261.         }
  262.     }
  263.  
  264. /* Add 1996.05.20 */
  265.         if( oc->core.orientation == XOMOrientation_TTB_RTL ||
  266.             oc->core.orientation == XOMOrientation_TTB_LTR ){
  267.         if (font_set->vpart_initialize == 0) {
  268.            load_fontdata(oc, font_set->vmap, font_set->vmap_num);
  269.            load_fontdata(oc, (FontData) font_set->vrotate,
  270.              font_set->vrotate_num);
  271.                 font_set->vpart_initialize = 1;
  272.         }
  273.         }
  274.  
  275.     if (font_set->font->min_byte1 || font_set->font->max_byte1)
  276.         font_set->is_xchar2b = True;
  277.     else
  278.         font_set->is_xchar2b = False;
  279.     }
  280.  
  281.     DBUG_RETURN(True);
  282. }
  283.  
  284. /* For VW/UDC end */
  285.  
  286. static Bool
  287. load_font_info(oc)
  288.     XOC oc;
  289. {
  290.     DBUG_ENTER("load_font_info")
  291.     Display *dpy = oc->core.om->core.display;
  292.     XOCGenericPart *gen = XOC_GENERIC(oc);
  293.     FontSet font_set = gen->font_set;
  294.     char **fn_list;
  295.     int fn_num, num = gen->font_set_num;
  296.  
  297.     for ( ; num-- > 0; font_set++) {
  298.     if (font_set->font_name == NULL)
  299.         continue;
  300.  
  301.     if (font_set->info == NULL) {
  302.         fn_list = XListFontsWithInfo(dpy, font_set->font_name, 1, &fn_num,
  303.                      &font_set->info);
  304.         if (font_set->info == NULL)
  305.         DBUG_RETURN(False);
  306.         
  307.         XFreeFontNames(fn_list);
  308.     }
  309.     }
  310.  
  311.     DBUG_RETURN(True);
  312. }
  313.  
  314. /* For Vertical Writing start */
  315.  
  316. static void
  317. check_fontset_extents(overall, logical_ascent, logical_descent, font)
  318.     XCharStruct        *overall;
  319.     int            *logical_ascent, *logical_descent;
  320.     XFontStruct        *font;
  321. {
  322.     DBUG_ENTER("check_fontset_extents")
  323.     overall->lbearing = min(overall->lbearing, font->min_bounds.lbearing);
  324.     overall->rbearing = max(overall->rbearing, font->max_bounds.rbearing);
  325.     overall->ascent   = max(overall->ascent,   font->max_bounds.ascent);
  326.     overall->descent  = max(overall->descent,  font->max_bounds.descent);
  327.     overall->width    = max(overall->width,    font->max_bounds.width);
  328.     *logical_ascent   = max(*logical_ascent,   font->ascent);
  329.     *logical_descent  = max(*logical_descent,  font->descent);
  330.     DBUG_VOID_RETURN;
  331. }
  332.  
  333. /* For Vertical Writing end */
  334.  
  335. static void
  336. set_fontset_extents(oc)
  337.     XOC oc;
  338. {
  339.     DBUG_ENTER("set_fontset_extents")
  340.     XRectangle *ink = &oc->core.font_set_extents.max_ink_extent;
  341.     XRectangle *logical = &oc->core.font_set_extents.max_logical_extent;
  342.     XFontStruct **font_list, *font;
  343.     XCharStruct overall;
  344.     int logical_ascent, logical_descent;
  345.     int    num = oc->core.font_info.num_font;
  346.  
  347.     font_list = oc->core.font_info.font_struct_list;
  348.     font = *font_list++;
  349.     overall = font->max_bounds;
  350.     overall.lbearing = font->min_bounds.lbearing;
  351.     logical_ascent = font->ascent;
  352.     logical_descent = font->descent;
  353.  
  354.     /* For Vertical Writing start */
  355.  
  356.     while (--num > 0) {
  357.     font = *font_list++;
  358.     check_fontset_extents(&overall, &logical_ascent, &logical_descent,
  359.                   font);
  360.     }
  361.  
  362.     {
  363.     XOCGenericPart  *gen = XOC_GENERIC(oc);
  364.     FontSet        font_set = gen->font_set;
  365.     FontData    font_data;
  366.     int        font_set_num = gen->font_set_num;
  367.     int        font_data_count;
  368.  
  369.     for( ; font_set_num-- ; font_set++) {
  370.         if(font_set->vmap_num > 0) {
  371.         font_data = font_set->vmap;
  372.         font_data_count = font_set->vmap_num;
  373.         for( ; font_data_count-- ; font_data++) {
  374.             if(font_data->font != NULL) {
  375.             check_fontset_extents(&overall, &logical_ascent,
  376.                           &logical_descent,
  377.                           font_data->font);
  378.             }
  379.         }
  380.         }
  381.  
  382.         if(font_set->vrotate_num > 0) {
  383.         font_data = (FontData) font_set->vrotate;
  384.         font_data_count = font_set->vrotate_num;
  385.         for( ; font_data_count-- ; font_data++) {
  386.             if(font_data != NULL)
  387.             if(font_data->font != NULL) {
  388.             check_fontset_extents(&overall, &logical_ascent,
  389.                           &logical_descent,
  390.                           font_data->font);
  391.             }
  392.         }
  393.         }
  394.     }
  395.     }
  396.  
  397.     /* For Vertical Writing start */
  398.  
  399.     ink->x = overall.lbearing;
  400.     ink->y = -(overall.ascent);
  401.     ink->width = overall.rbearing - overall.lbearing;
  402.     ink->height = overall.ascent + overall.descent;
  403.  
  404.     logical->x = 0;
  405.     logical->y = -(logical_ascent);
  406.     logical->width = overall.width;
  407.     logical->height = logical_ascent + logical_descent;
  408.     DBUG_VOID_RETURN;
  409. }
  410.  
  411. static Bool
  412. init_core_part(oc)
  413.     XOC oc;
  414. {
  415.     DBUG_ENTER("init_core_part")
  416.     XOCGenericPart *gen = XOC_GENERIC(oc);
  417.     FontSet font_set;
  418.     int font_set_num;
  419.     XFontStruct **font_struct_list;
  420.     char **font_name_list, *font_name_buf;
  421.     int    count, length;
  422.  
  423.     font_set = gen->font_set;
  424.     font_set_num = gen->font_set_num;
  425.     count = length = 0;
  426.  
  427.     for ( ; font_set_num-- > 0; font_set++) {
  428.     if (font_set->font_name == NULL)
  429.         continue;
  430.  
  431.     length += strlen(font_set->font_name) + 1;
  432.     count++;
  433.     }
  434.     if (count == 0)
  435.         DBUG_RETURN(False);
  436.  
  437.     font_struct_list = (XFontStruct **) Xmalloc(sizeof(XFontStruct *) * count);
  438.     if (font_struct_list == NULL)
  439.     DBUG_RETURN(False);
  440.  
  441.     font_name_list = (char **) Xmalloc(sizeof(char *) * count);
  442.     if (font_name_list == NULL)
  443.     goto err;
  444.  
  445.     font_name_buf = (char *) Xmalloc(length);
  446.     if (font_name_buf == NULL)
  447.     goto err;
  448.  
  449.     oc->core.font_info.num_font = count;
  450.     oc->core.font_info.font_name_list = font_name_list;
  451.     oc->core.font_info.font_struct_list = font_struct_list;
  452.  
  453.     font_set = gen->font_set;
  454.     font_set_num = gen->font_set_num;
  455.  
  456.     for (count = 0; font_set_num-- > 0; font_set++, count++) {
  457.     if (font_set->font_name == NULL)
  458.         continue;
  459.  
  460.     font_set->id = count;
  461.     if (font_set->font)
  462.         *font_struct_list++ = font_set->font;
  463.     else
  464.         *font_struct_list++ = font_set->info;
  465.     strcpy(font_name_buf, font_set->font_name);
  466.     Xfree(font_set->font_name);
  467.     *font_name_list++ = font_set->font_name = font_name_buf;
  468.     font_name_buf += strlen(font_name_buf) + 1;
  469.     }
  470.  
  471.     set_fontset_extents(oc);
  472.  
  473.     DBUG_RETURN(True);
  474.  
  475. err:
  476.     if (font_name_list)
  477.     Xfree(font_name_list);
  478.     Xfree(font_struct_list);
  479.  
  480.     DBUG_RETURN(False);
  481. }
  482.  
  483. static char *
  484. get_font_name(oc, pattern)
  485.     XOC oc;
  486.     char *pattern;
  487. {
  488.     DBUG_ENTER("get_font_name")
  489.     char **list, *name;
  490.     int count = 0;
  491.  
  492.     list = XListFonts(oc->core.om->core.display, pattern, 1, &count);
  493.     if (list == NULL)
  494.     DBUG_RETURN(NULL);
  495.  
  496.     name = (char *) Xmalloc(strlen(*list) + 1);
  497.     if (name)
  498.     strcpy(name, *list);
  499.     
  500.     XFreeFontNames(list);
  501.  
  502.     DBUG_RETURN(name);
  503. }
  504.  
  505. /* For VW/UDC start*/
  506.  
  507. static char
  508. *get_rotate_fontname(font_name)
  509.     char *font_name;
  510. {
  511.     DBUG_ENTER("get_rotate_fontname")
  512.     char *pattern = NULL, *ptr = NULL;
  513.     char *fields[CHARSET_ENCODING_FIELD];
  514.     char str_pixel[32], str_point[4];
  515.     char *rotate_font_ptr = NULL;
  516.     int pixel_size = 0;
  517.     int field_num = 0, len = 0;
  518.  
  519.     if(font_name == (char *) NULL || (len = strlen(font_name)) <= 0)
  520.     DBUG_RETURN(NULL);
  521.  
  522.     pattern = (char *)Xmalloc(len + 1);
  523.     if(!pattern)
  524.     DBUG_RETURN(NULL);
  525.     strcpy(pattern, font_name);
  526.  
  527.     memset(fields, '\0', sizeof(char *) * 14);
  528.     ptr = pattern;
  529.     while(isspace(*ptr)) {
  530.     ptr++;
  531.     }
  532.     if(*ptr == '-')
  533.     ptr++;
  534.  
  535.     for(field_num = 0 ; field_num < CHARSET_ENCODING_FIELD && ptr && *ptr ;
  536.             ptr++, field_num++) {
  537.     fields[field_num] = ptr;
  538.  
  539.     if(ptr = strchr(ptr, '-')) {
  540.         *ptr = '\0';
  541.     }
  542.     }
  543.  
  544.     if(field_num < CHARSET_ENCODING_FIELD)
  545.     DBUG_RETURN(NULL);
  546.  
  547.     /* Pixel Size field : fields[6] */
  548.     for(ptr = fields[PIXEL_SIZE_FIELD - 1] ; ptr && *ptr; ptr++) {
  549.     if(!isdigit(*ptr)) {
  550.         if(*ptr == '['){ /* 960730 */
  551.             strcpy(pattern, font_name);
  552.         return(pattern);
  553.         }
  554.         if(pattern)
  555.         Xfree(pattern);
  556.         DBUG_RETURN(NULL);
  557.     }
  558.     }
  559.     pixel_size = atoi(fields[PIXEL_SIZE_FIELD - 1]);
  560.     sprintf(str_pixel, "[ 0 ~%d %d 0 ]", pixel_size, pixel_size);
  561.     fields[6] = str_pixel;
  562.  
  563.     /* Point Size field : fields[7] */
  564.     strcpy(str_point, "*");
  565.     fields[POINT_SIZE_FIELD - 1] = str_point;
  566.  
  567.     len = 0;
  568.     for (field_num = 0; field_num < CHARSET_ENCODING_FIELD &&
  569.             fields[field_num]; field_num++) {
  570.     len += 1 + strlen(fields[field_num]);
  571.     }
  572.  
  573.     /* Max XLFD length is 255 */
  574.     if (len > 255) 
  575.     DBUG_RETURN(NULL);
  576.  
  577.     rotate_font_ptr = (char *)Xmalloc(len + 1);
  578.     if(!rotate_font_ptr)
  579.     DBUG_RETURN(NULL);
  580.  
  581.     rotate_font_ptr[0] = '\0';
  582.  
  583.     for(field_num = 0 ; field_num < CHARSET_ENCODING_FIELD &&
  584.             fields[field_num] ; field_num++) {
  585.     sprintf(rotate_font_ptr, "%s-%s", rotate_font_ptr, fields[field_num]);
  586.     }
  587.  
  588.     if(pattern)
  589.     Xfree(pattern);
  590.  
  591.     DBUG_RETURN(rotate_font_ptr);
  592. }
  593.  
  594. static Bool
  595. is_match_charset(font_data, font_name)
  596.     FontData    font_data;
  597.     char    *font_name;
  598. {
  599.     DBUG_ENTER("is_match_charset")
  600.     char *last;
  601.     int length, name_len;
  602.  
  603.     name_len = strlen(font_name);
  604.     last = font_name + name_len;
  605.  
  606.     length = strlen(font_data->name);
  607.     if (length > name_len)
  608.     DBUG_RETURN(False);
  609.     
  610.     if (_XlcCompareISOLatin1(last - length, font_data->name) == 0)
  611.     DBUG_RETURN(True);
  612.  
  613.     DBUG_RETURN(False);
  614. }
  615.  
  616. static int
  617. parse_all_name(oc, font_data, pattern)
  618.     XOC        oc;
  619.     FontData    font_data;
  620.     char    *pattern;
  621. {
  622.     DBUG_ENTER("parse_all_name")
  623.  
  624. #ifdef OLDCODE
  625.     if(is_match_charset(font_data, pattern) != True)
  626.      return False;
  627.  
  628.     font_data->xlfd_name = (char *)Xmalloc(strlen(pattern)+1);
  629.     if(font_data->xlfd_name == NULL)
  630.     return (-1);
  631.  
  632.     strcpy(font_data->xlfd_name, pattern);
  633.     DBUG_RETURN(True);
  634. #else  /* OLDCODE */
  635.     Display *dpy = oc->core.om->core.display;
  636.     char **fn_list = NULL, *prop_fname = NULL;
  637.     int list_num;
  638.     XFontStruct *fs_list;
  639.     if(is_match_charset(font_data, pattern) != True) {
  640.     if ((fn_list = XListFontsWithInfo(dpy, pattern,
  641.                       MAXFONTS,
  642.                       &list_num, &fs_list))
  643.         && (prop_fname = get_prop_name(dpy, fs_list))
  644.         && (is_match_charset(font_data, prop_fname) != True)) {
  645.         if (fn_list) {
  646.             XFreeFontInfo(fn_list, fs_list, list_num);
  647.             fn_list = NULL;
  648.         }
  649.         DBUG_RETURN(False);
  650.         }
  651.     font_data->xlfd_name = prop_fname;
  652.         if (fn_list) {
  653.         XFreeFontInfo(fn_list, fs_list, list_num);
  654.     }
  655.     DBUG_RETURN(True);
  656.     }
  657.  
  658.     font_data->xlfd_name = (char *)Xmalloc(strlen(pattern)+1);
  659.     if(font_data->xlfd_name == NULL)
  660.     DBUG_RETURN(-1);
  661.  
  662.     strcpy(font_data->xlfd_name, pattern);
  663.     DBUG_RETURN(True);
  664. #endif /* OLDCODE */
  665. }
  666.  
  667. static int
  668. parse_omit_name(oc, font_data, pattern)
  669.     XOC        oc;
  670.     FontData    font_data;
  671.     char    *pattern;
  672. {
  673.     DBUG_ENTER("parse_omit_name")
  674.     char    *font_name = (char *) NULL;
  675.     char    *last = (char *) NULL;
  676.     char    *base_name;
  677.     char    buf[BUFSIZE];
  678.     int        length = 0;
  679.     int        num_fields;
  680.     char    *end;
  681.  
  682.     if (strlen(pattern) >= sizeof(buf))
  683.     DBUG_RETURN(-1);
  684.  
  685.     if(is_match_charset(font_data, pattern) == True) {
  686.     strcpy(buf, pattern);
  687.     length = strlen(pattern);
  688.     if (font_name = get_font_name(oc, buf)) {
  689.         font_data->xlfd_name = (char *)Xmalloc(strlen(font_name) + 1);
  690.         if(font_data->xlfd_name == NULL) {
  691.         Xfree(font_name);
  692.         DBUG_RETURN(-1);
  693.         }
  694.         strcpy(font_data->xlfd_name, font_name);
  695.         Xfree(font_name);
  696.         DBUG_RETURN(True);
  697.     }
  698.     }
  699.  
  700.     strcpy(buf, pattern);
  701.     length = strlen(pattern);
  702.     last = buf + length - 1;
  703.     end = buf + sizeof(buf) - 1;
  704.  
  705. #define CHECK_SPACE(n) if (end - last <= (n)) return -1; else
  706.     /* 
  707.      * Plug in the charset/encoding specified in the XLC_LOCALE file
  708.      * into the *right* place in the XLFD name.
  709.      */
  710.     for (num_fields = 0, base_name = buf; *base_name != '\0'; base_name++)
  711.     if (*base_name == '-') num_fields++;
  712.  
  713.     switch (num_fields) {
  714.     case 12:
  715.     /* this is the best way to have specifed the fontset */
  716.     CHECK_SPACE(1);
  717.     *++last = '-';
  718.     break;
  719.     case 13:
  720.     /* got the charset, not the encoding, zap the charset */
  721.     last = strrchr (buf, '-');
  722.     num_fields = 12;
  723.     break;
  724.     case 14:
  725.     /* got the charset and the encoding, zap 'em */
  726.     last = strrchr (buf, '-');
  727.     *last = '\0';
  728.     last = strrchr (buf, '-');
  729.     num_fields = 12;
  730.     break;
  731.     default:
  732.     /* punt */
  733.     if (length > 1 && *last == '*' && *(last - 1) == '-') {
  734.         if (length > 3 && *(last - 2) == '*' && *(last - 3) == '-')
  735.         last -= 3;
  736.         else
  737.         last--;
  738.     } else {
  739.         CHECK_SPACE(1);
  740.         *++last = '-';
  741.     }
  742.     break;
  743.     }
  744.     last++;
  745.  
  746.     CHECK_SPACE(strlen(font_data->name));
  747.     strcpy(last, font_data->name);
  748.     if (font_name = get_font_name(oc, buf)) {
  749.     font_data->xlfd_name = (char *)Xmalloc(strlen(font_name) + 1);
  750.     if(font_data->xlfd_name == NULL) {
  751.         Xfree(font_name);
  752.         DBUG_RETURN(-1);
  753.     }
  754.     strcpy(font_data->xlfd_name, font_name);
  755.     Xfree(font_name);
  756.     DBUG_RETURN(True);
  757.     }
  758.  
  759.     while (num_fields < 12) {
  760.     CHECK_SPACE(2 + strlen(font_data->name));
  761.     *last = '*';
  762.     *(last + 1) = '-';
  763.     strcpy(last + 2, font_data->name);
  764.     num_fields++; 
  765.     last+=2;
  766.     if (font_name = get_font_name(oc, buf)) {
  767.         font_data->xlfd_name = (char *)Xmalloc(strlen(font_name) + 1);
  768.         if(font_data->xlfd_name == NULL) {
  769.         Xfree(font_name);
  770.         DBUG_RETURN(-1);
  771.         }
  772.         strcpy(font_data->xlfd_name, font_name);
  773.         Xfree(font_name);
  774.         DBUG_RETURN(True);
  775.     }
  776.     }
  777.  
  778.     DBUG_RETURN(False);
  779. }
  780.  
  781.  
  782. typedef enum{C_PRIMARY, C_SUBSTITUTE, C_VMAP, C_VROTATE } ClassType;
  783.  
  784. static int
  785. parse_fontdata(oc, font_data, font_data_count, name_list, name_list_count,
  786.         class)
  787.     XOC        oc;
  788.     FontData    font_data;
  789.     int        font_data_count;
  790.     char    **name_list;
  791.     int        name_list_count;
  792.     ClassType    class;
  793. {
  794.     DBUG_ENTER("parse_fontdata")
  795.     char    **cur_name_list = name_list;
  796.     char    *font_name = (char *) NULL;
  797.     char    *pattern = (char *) NULL;
  798.     int        found_num = 0, ret = 0;
  799.     int        fd_count = font_data_count;
  800.     int        count = name_list_count;
  801.     Bool    is_found = False;
  802.  
  803.     if(name_list == NULL || count <= 0) {
  804.     DBUG_RETURN(False);
  805.     }
  806.  
  807.     if(font_data == NULL || font_data_count <= 0) {
  808.     DBUG_RETURN(False);
  809.     }
  810.  
  811.     for ( ; font_data_count-- > 0; font_data++) {
  812.     is_found = False;
  813.     font_name = (char *) NULL;
  814.     count = name_list_count;
  815.     cur_name_list = name_list;
  816.     while (count-- > 0) {
  817.             pattern = *cur_name_list++;
  818.         if (pattern == NULL || *pattern == '\0')
  819.         continue;
  820.  
  821.  
  822.         /* When the font name is specified a full name. */
  823.         if (strchr(pattern, '*') == NULL &&
  824.         (font_name = get_font_name(oc, pattern))) {
  825.  
  826.  
  827.         ret = parse_all_name(oc, font_data, font_name);
  828.         Xfree(font_name);
  829.  
  830.  
  831.         if(ret == -1) {
  832.             DBUG_RETURN(ret);
  833.         } else if (ret == True) {
  834.             found_num++;
  835.             is_found = True;
  836.             break;
  837.         } else
  838.             continue;
  839.         }
  840.  
  841.         /* When the font name is specified a omited name. */
  842.         ret = parse_omit_name(oc, font_data, pattern);
  843.         if(ret == -1) {
  844.             DBUG_RETURN(ret);
  845.         } else if (ret == True) {
  846.             found_num++;
  847.             is_found = True;
  848.             break;
  849.         } else
  850.             continue;
  851.     }
  852.  
  853.     switch(class) {
  854.       case C_PRIMARY:
  855.         if(is_found != True)
  856.         DBUG_RETURN(False);
  857.         break;
  858.       case C_SUBSTITUTE:
  859.       case C_VMAP:
  860.         if(is_found == True)
  861.         DBUG_RETURN(True);
  862.         break;
  863.       case C_VROTATE:
  864.         if(is_found == True) {
  865.         char    *rotate_name;
  866.  
  867.         if((rotate_name = get_rotate_fontname(font_data->xlfd_name)) !=
  868.                   NULL) {
  869.             Xfree(font_data->xlfd_name);
  870.             font_data->xlfd_name = rotate_name;
  871.             DBUG_RETURN(True);
  872.         }
  873.         Xfree(font_data->xlfd_name);
  874.         DBUG_RETURN(False);
  875.         }
  876.     }
  877.     }
  878.  
  879.     if(class == C_PRIMARY && found_num == fd_count)
  880.     DBUG_RETURN(True);
  881.  
  882.     DBUG_RETURN(False);
  883. }
  884.  
  885.  
  886. static int
  887. parse_vw(oc, font_set, name_list, count)
  888.     XOC        oc;
  889.     FontSet    font_set;
  890.     char    **name_list;
  891.     int        count;
  892. {
  893.     DBUG_ENTER("parse_vw")
  894.     FontData    vmap = font_set->vmap;
  895.     VRotate    vrotate = font_set->vrotate;
  896.     int        vmap_num = font_set->vmap_num;
  897.     int        vrotate_num = font_set->vrotate_num;
  898.     int        ret = 0, i = 0;
  899.  
  900.     if(vmap_num > 0) {
  901.     if(parse_fontdata(oc, vmap, vmap_num, name_list, count, C_VMAP) == -1)
  902.         DBUG_RETURN(-1);
  903.     }
  904.  
  905.     if(vrotate_num > 0) {
  906.     ret = parse_fontdata(oc, (FontData) vrotate, vrotate_num,
  907.                  name_list, count, C_VROTATE);
  908.     if(ret == -1) {
  909.         DBUG_RETURN(-1);
  910.     } else if(ret == False) {
  911.         CodeRange    code_range;
  912.         int        num_cr;
  913.         int        sub_num = font_set->substitute_num;
  914.  
  915.         code_range = vrotate[i].code_range;
  916.         num_cr = vrotate[i].num_cr;
  917.         for(i = 0 ; i < vrotate_num ; i++) {
  918.         if(vrotate[i].xlfd_name)
  919.             Xfree(vrotate[i].xlfd_name);
  920.         }
  921.         Xfree(vrotate);
  922.  
  923.         if(sub_num > 0) {
  924.         vrotate = font_set->vrotate = (VRotate)Xmalloc
  925.                         (sizeof(VRotateRec) * sub_num);
  926.         if(font_set->vrotate == (VRotate)NULL)
  927.             DBUG_RETURN(-1);
  928.  
  929.         for(i = 0 ; i < sub_num ; i++) {
  930.             vrotate[i].charset_name = font_set->substitute[i].name;
  931.             vrotate[i].side = font_set->substitute[i].side;
  932.             vrotate[i].code_range = code_range;
  933.             vrotate[i].num_cr = num_cr;
  934.         }
  935.         vrotate_num = font_set->vrotate_num = sub_num;
  936.         } else {
  937.         font_set->vrotate = (VRotate)NULL;
  938.         }
  939.  
  940.         ret = parse_fontdata(oc, (FontData) vrotate, vrotate_num,
  941.                  name_list, count, C_VROTATE);
  942.         if(ret == -1)
  943.         DBUG_RETURN(-1);
  944.     }
  945.     }
  946.  
  947.     DBUG_RETURN(True);
  948. }
  949.  
  950. static int
  951. parse_fontname(oc)
  952.     XOC oc;
  953. {
  954.     DBUG_ENTER("parse_fontname")
  955.     XOCGenericPart *gen = XOC_GENERIC(oc);
  956.     FontSet font_set;
  957.     char *base_name, **name_list;
  958.     int font_set_num = 0;
  959.     int found_num = 0;
  960.     int count = 0;
  961.     int    ret;
  962.     int i;
  963.  
  964.     name_list = _XParseBaseFontNameList(oc->core.base_name_list, &count);
  965.     if (name_list == NULL)
  966.     DBUG_RETURN(-1);
  967.  
  968.     font_set = gen->font_set;
  969.     font_set_num = gen->font_set_num;
  970.  
  971.     for( ; font_set_num-- > 0 ; font_set++) {
  972.     if(font_set->font_name)
  973.         continue;
  974.  
  975.     if(font_set->font_data_count > 0) {
  976.         ret = parse_fontdata(oc, font_set->font_data,
  977.                  font_set->font_data_count,
  978.                  name_list, count, C_PRIMARY);
  979.         if(ret == -1) {
  980.         goto err;
  981.         } else if(ret == True) {
  982.         font_set->font_name = (char *)Xmalloc
  983.             (strlen(font_set->font_data->xlfd_name) + 1);
  984.         if(font_set->font_name == (char *) NULL)
  985.             goto err;
  986.         strcpy(font_set->font_name, font_set->font_data->xlfd_name);
  987.         font_set->side = font_set->font_data->side;
  988.  
  989.         if(parse_vw(oc, font_set, name_list, count) == -1)
  990.             goto err;
  991.         found_num++;
  992.  
  993.         /* The substitute font is serched, when the primary fonts */
  994.         /* is not found. */
  995.         } else {
  996.         /* The primary information is free from FontSet structure */
  997.         font_set->font_data_count = 0;
  998.         if(font_set->font_data) {
  999.             Xfree(font_set->font_data);
  1000.             font_set->font_data = (FontData) NULL;
  1001.         }
  1002.  
  1003.         /* A vrotate member is replaced to substitute information */
  1004.         /* from primary information. */
  1005.         font_set->vrotate_num = 0;
  1006.         if(font_set->vrotate) {
  1007.             Xfree(font_set->vrotate);
  1008.             font_set->vrotate = (VRotate) NULL;
  1009.         }
  1010.  
  1011.         ret = parse_fontdata(oc, font_set->substitute,
  1012.                      font_set->substitute_num,
  1013.                      name_list, count, C_SUBSTITUTE);
  1014.         if(ret == -1) {
  1015.             goto err;
  1016.         } else if(ret == True) {
  1017.             for(i=0;i<font_set->substitute_num;i++){
  1018.             if(font_set->substitute[i].xlfd_name != NULL){
  1019.                 break;
  1020.             }
  1021.             }
  1022.             font_set->font_name = (char *)Xmalloc
  1023.                 (strlen(font_set->substitute[i].xlfd_name) + 1);
  1024.             if(font_set->font_name == (char *) NULL)
  1025.             goto err;
  1026.             strcpy(font_set->font_name,font_set->substitute[i].xlfd_name);
  1027.             font_set->side = font_set->substitute[i].side;
  1028.             if(parse_vw(oc, font_set, name_list, count) == -1)
  1029.             goto err;
  1030.             found_num++;
  1031.         }
  1032.         }
  1033.     } else if(font_set->substitute_num > 0) {
  1034.         ret = parse_fontdata(oc, font_set->substitute,
  1035.                  font_set->substitute_num,
  1036.                  name_list, count, C_SUBSTITUTE);
  1037.         if(ret == -1) {
  1038.         goto err;
  1039.         } else if(ret == True) {
  1040.         for(i=0;i<font_set->substitute_num;i++){
  1041.             if(font_set->substitute[i].xlfd_name != NULL){
  1042.             break;
  1043.             }
  1044.         }
  1045.         font_set->font_name = (char *)Xmalloc
  1046.                 (strlen(font_set->substitute[i].xlfd_name) + 1);
  1047.         if(font_set->font_name == (char *) NULL)
  1048.             goto err;
  1049.         strcpy(font_set->font_name,font_set->substitute[i].xlfd_name);
  1050.         font_set->side = font_set->substitute[i].side;
  1051.         if(parse_vw(oc, font_set, name_list, count) == -1)
  1052.             goto err;
  1053.  
  1054.         found_num++;
  1055.         }
  1056.     }
  1057.     }
  1058.  
  1059.     base_name = (char *) Xmalloc(strlen(oc->core.base_name_list) + 1);
  1060.     if (base_name == NULL)
  1061.     goto err;
  1062.  
  1063.     strcpy(base_name, oc->core.base_name_list);
  1064.     oc->core.base_name_list = base_name;
  1065.  
  1066.     XFreeStringList(name_list);        
  1067.  
  1068.     DBUG_RETURN(found_num);
  1069.  
  1070. err:
  1071.     XFreeStringList(name_list);
  1072.     /* Prevent this from being freed twice */
  1073.     oc->core.base_name_list = NULL;
  1074.  
  1075.     DBUG_RETURN(-1);
  1076. }
  1077.  
  1078. /* For VW/UDC end*/
  1079.  
  1080. static Bool
  1081. set_missing_list(oc)
  1082.     XOC oc;
  1083. {
  1084.     DBUG_ENTER("set_missing_list")
  1085.     XOCGenericPart *gen = XOC_GENERIC(oc);
  1086.     FontSet font_set;
  1087.     char **charset_list, *charset_buf;
  1088.     int    count, length, font_set_num;
  1089.     int result = 1;
  1090.  
  1091.     font_set = gen->font_set;
  1092.     font_set_num = gen->font_set_num;
  1093.     count = length = 0;
  1094.  
  1095.     for ( ; font_set_num-- > 0; font_set++) {
  1096.     if (font_set->info || font_set->font) {
  1097.         continue;
  1098.     }
  1099.     
  1100.     /* Change 1996.01.23 start */
  1101.     if(font_set->font_data_count <= 0 ||
  1102.        font_set->font_data == (FontData)NULL) {
  1103.         if(font_set->substitute_num <= 0 ||
  1104.            font_set->substitute == (FontData)NULL) {
  1105.         if(font_set->charset_list != NULL){
  1106.          length += 
  1107.           strlen(font_set->charset_list[0]->encoding_name) + 1;
  1108.         } else {
  1109.           length += 1;
  1110.         }
  1111.         } else {
  1112.         length += strlen(font_set->substitute->name) + 1;
  1113.         }
  1114.     } else {
  1115.         length += strlen(font_set->font_data->name) + 1;
  1116.     }
  1117.     /* Change 1996.01.23 end */
  1118.     count++;
  1119.     }
  1120.  
  1121.     if (count < 1) {
  1122.     DBUG_RETURN(True);
  1123.     }
  1124.  
  1125.     charset_list = (char **) Xmalloc(sizeof(char *) * count);
  1126.     if (charset_list == NULL) {
  1127.     DBUG_RETURN(False);
  1128.     }
  1129.  
  1130.     charset_buf = (char *) Xmalloc(length);
  1131.     if (charset_buf == NULL) {
  1132.     Xfree(charset_list);
  1133.     DBUG_RETURN(False);
  1134.     }
  1135.  
  1136.     oc->core.missing_list.charset_list = charset_list;
  1137.     oc->core.missing_list.charset_count = count;
  1138.  
  1139.     font_set = gen->font_set;
  1140.     font_set_num = gen->font_set_num;
  1141.  
  1142.     for ( ; font_set_num-- > 0; font_set++) {
  1143.     if (font_set->info || font_set->font) {
  1144.         continue;
  1145.     }
  1146.  
  1147.     /* Change 1996.01.23 start */
  1148.     if(font_set->font_data_count <= 0 ||
  1149.        font_set->font_data == (FontData)NULL) {
  1150.         if(font_set->substitute_num <= 0 ||
  1151.            font_set->substitute == (FontData)NULL) {
  1152.         if(font_set->charset_list != NULL){
  1153.          strcpy(charset_buf,
  1154.             font_set->charset_list[0]->encoding_name);
  1155.         } else {
  1156.          strcpy(charset_buf, "");
  1157.         }
  1158.         result = 0;
  1159.         } else {
  1160.         strcpy(charset_buf, font_set->substitute->name);
  1161.         }
  1162.     } else {
  1163.         strcpy(charset_buf, font_set->font_data->name);
  1164.     }
  1165.     /* Change 1996.01.23 end */
  1166.     *charset_list++ = charset_buf;
  1167.     charset_buf += strlen(charset_buf) + 1;
  1168.     } 
  1169.  
  1170.     if(result == 0) {
  1171.     DBUG_RETURN(False);
  1172.     }
  1173.  
  1174.     DBUG_RETURN(True);
  1175. }
  1176.  
  1177. static Bool
  1178. create_fontset(oc)
  1179.     XOC oc;
  1180. {
  1181.     DBUG_ENTER("create_fontset")
  1182.     XOMGenericPart *gen = XOM_GENERIC(oc->core.om);
  1183.     int found_num;
  1184.  
  1185.     if (init_fontset(oc) == False)
  1186.         DBUG_RETURN(False);
  1187.  
  1188.     found_num = parse_fontname(oc);
  1189.     if (found_num <= 0) {
  1190.     if (found_num == 0)
  1191.         set_missing_list(oc);
  1192.     DBUG_RETURN(False);
  1193.     }
  1194.  
  1195.     if (gen->on_demand_loading == True) {
  1196.     if (load_font_info(oc) == False)
  1197.         DBUG_RETURN(False);
  1198.     } else {
  1199.     if (load_font(oc) == False)
  1200.         DBUG_RETURN(False);
  1201.     }
  1202.  
  1203.     if (init_core_part(oc) == False)
  1204.     DBUG_RETURN(False);
  1205.  
  1206.     if (set_missing_list(oc) == False)
  1207.     DBUG_RETURN(False);
  1208.  
  1209.     DBUG_RETURN(True);
  1210. }
  1211.  
  1212. /* For VW/UDC start */
  1213. static void
  1214. free_fontdataOC(dpy,font_data, font_data_count)
  1215.     Display    *dpy;
  1216.     FontData    font_data;
  1217.     int        font_data_count;
  1218. {
  1219.     DBUG_ENTER("free_fontdataOC")
  1220.     for( ; font_data_count-- ; font_data++) {
  1221.     if(font_data->xlfd_name){
  1222.         Xfree(font_data->xlfd_name);
  1223.         font_data->xlfd_name = NULL;
  1224.     }
  1225.     if(font_data->font){                /* ADD 1996.01.7 */
  1226.         if(font_data->font->fid)            /* Add 1996.01.23 */
  1227.         XFreeFont(dpy,font_data->font);        /* ADD 1996.01.7 */
  1228.         else                    /* Add 1996.01.23 */
  1229.         XFreeFontInfo(NULL, font_data->font, 1);/* Add 1996.01.23 */
  1230.         font_data->font = NULL;
  1231.     }
  1232. /* XOM to kyoutuu shite shiyou sushiteiru ryouiki
  1233.    kokoha free_fontdataOM() de free sareru
  1234.  
  1235.     if(font_data->scopes){
  1236.         Xfree(font_data->scopes);
  1237.         font_data->scopes = NULL;
  1238.     }
  1239.     if(font_data->name){
  1240.         Xfree(font_data->name);
  1241.         font_data->name = NULL;
  1242.     }
  1243. */
  1244.     }
  1245.     DBUG_VOID_RETURN;
  1246. }
  1247.  
  1248. void destroy_fontdata(gen,dpy)
  1249.     XOCGenericPart *gen ;
  1250.     Display *dpy ;
  1251. {
  1252.     DBUG_ENTER("destroy_fontdata")
  1253.     FontSet    font_set = (FontSet) NULL;
  1254.     int        font_set_num = 0;
  1255.  
  1256.     if (gen->font_set) {
  1257.     font_set = gen->font_set;
  1258.     font_set_num = gen->font_set_num;
  1259.     for( ; font_set_num-- ; font_set++) {
  1260.         if(font_set->font_data) {
  1261.         free_fontdataOC(dpy,
  1262.             font_set->font_data, font_set->font_data_count);
  1263.         Xfree(font_set->font_data);
  1264.         font_set->font_data = NULL;
  1265.         }
  1266.         if(font_set->substitute) {
  1267.         free_fontdataOC(dpy,
  1268.             font_set->substitute, font_set->substitute_num);
  1269.         Xfree(font_set->substitute);
  1270.         font_set->substitute = NULL;
  1271.         }
  1272.         if(font_set->vmap) {
  1273.         free_fontdataOC(dpy,
  1274.             font_set->vmap, font_set->vmap_num);
  1275.         Xfree(font_set->vmap);
  1276.         font_set->vmap = NULL;
  1277.         }
  1278.         if(font_set->vrotate) {
  1279.         free_fontdataOC(dpy,
  1280.             (FontData)font_set->vrotate,
  1281.                   font_set->vrotate_num);
  1282.         Xfree(font_set->vrotate);
  1283.         font_set->vrotate = NULL;
  1284.         }
  1285.     }
  1286.     Xfree(gen->font_set);
  1287.     gen->font_set = NULL;
  1288.     }
  1289.     DBUG_VOID_RETURN;
  1290. }
  1291. /* For VW/UDC end */
  1292.  
  1293. static void
  1294. destroy_oc(oc)
  1295.     XOC oc;
  1296. {
  1297.     DBUG_ENTER("destroy_oc")
  1298.     Display *dpy = oc->core.om->core.display;
  1299.     XOCGenericPart *gen = XOC_GENERIC(oc);
  1300.     XFontStruct **font_list, *font;
  1301.     FontSet    font_set = (FontSet) NULL;
  1302.     int        font_set_num = 0;
  1303.     int        count = 0;
  1304.  
  1305.     if (gen->mbs_to_cs)
  1306.     _XlcCloseConverter(gen->mbs_to_cs);
  1307.  
  1308.     if (gen->wcs_to_cs)
  1309.     _XlcCloseConverter(gen->wcs_to_cs);
  1310.  
  1311. /* For VW/UDC start */ /* Change 1996.01.8 */
  1312.     destroy_fontdata(gen,dpy); 
  1313. /*
  1314. */
  1315. /* For VW/UDC end */
  1316.  
  1317.     if (oc->core.base_name_list)
  1318.     Xfree(oc->core.base_name_list);
  1319.  
  1320.     if (oc->core.font_info.font_name_list)
  1321.     XFreeStringList(oc->core.font_info.font_name_list);
  1322.  
  1323.     if (font_list = oc->core.font_info.font_struct_list) {
  1324.     Xfree(oc->core.font_info.font_struct_list);
  1325.     }
  1326.  
  1327.     if (oc->core.missing_list.charset_list)
  1328.     XFreeStringList(oc->core.missing_list.charset_list);
  1329.  
  1330. #ifdef notdef
  1331.     if (oc->core.res_name)
  1332.     Xfree(oc->core.res_name);
  1333.     if (oc->core.res_class)
  1334.     Xfree(oc->core.res_class);
  1335. #endif
  1336.     
  1337.     Xfree(oc);
  1338.     DBUG_VOID_RETURN;
  1339. }
  1340.  
  1341. static char *
  1342. set_oc_values(oc, args, num_args)
  1343.     XOC oc;
  1344.     XlcArgList args;
  1345.     int num_args;
  1346. {
  1347.     DBUG_ENTER("set_oc_values")
  1348.     int i;
  1349.     XOCGenericPart *gen = XOC_GENERIC(oc);
  1350.     FontSet font_set = gen->font_set;
  1351.     char *ret;
  1352.     int num = gen->font_set_num;
  1353.  
  1354.     if (oc->core.resources == NULL)
  1355.     DBUG_RETURN(NULL);
  1356.  
  1357.     ret = _XlcSetValues((XPointer) oc, oc->core.resources,
  1358.             oc->core.num_resources, args, num_args, XlcSetMask);
  1359.     if(ret != NULL){
  1360.     DBUG_RETURN(ret);
  1361.     } else {
  1362.     for ( ; num-- > 0; font_set++) {
  1363.         if (font_set->font_name == NULL)
  1364.             continue;
  1365.         if (font_set->vpart_initialize != 0)
  1366.             continue;
  1367.         if( oc->core.orientation == XOMOrientation_TTB_RTL ||
  1368.         oc->core.orientation == XOMOrientation_TTB_LTR ){
  1369.             load_fontdata(oc, font_set->vmap, font_set->vmap_num);
  1370.         load_fontdata(oc, (FontData) font_set->vrotate,
  1371.                 font_set->vrotate_num);
  1372.         font_set->vpart_initialize = 1;
  1373.         }
  1374.     }
  1375.     DBUG_RETURN(NULL);
  1376.     }
  1377. }
  1378.  
  1379. static char *
  1380. get_oc_values(oc, args, num_args)
  1381.     XOC oc;
  1382.     XlcArgList args;
  1383.     int num_args;
  1384. {
  1385.     DBUG_ENTER("get_oc_values")
  1386.     char *result;
  1387.     if (oc->core.resources == NULL)
  1388.     DBUG_RETURN(NULL);
  1389.  
  1390.     result = _XlcGetValues((XPointer) oc, oc->core.resources,
  1391.              oc->core.num_resources, args, num_args, XlcGetMask);
  1392.     DBUG_RETURN(result);
  1393. }
  1394.  
  1395. static XOCMethodsRec oc_default_methods = {
  1396.     destroy_oc,
  1397.     set_oc_values,
  1398.     get_oc_values,
  1399.     _XmbDefaultTextEscapement,
  1400.     _XmbDefaultTextExtents,
  1401.     _XmbDefaultTextPerCharExtents,
  1402.     _XmbDefaultDrawString,
  1403.     _XmbDefaultDrawImageString,
  1404.     _XwcDefaultTextEscapement,
  1405.     _XwcDefaultTextExtents,
  1406.     _XwcDefaultTextPerCharExtents,
  1407.     _XwcDefaultDrawString,
  1408.     _XwcDefaultDrawImageString
  1409. };
  1410.  
  1411. static XOCMethodsRec oc_generic_methods = {
  1412.     destroy_oc,
  1413.     set_oc_values,
  1414.     get_oc_values,
  1415.     _XmbGenericTextEscapement,
  1416.     _XmbGenericTextExtents,
  1417.     _XmbGenericTextPerCharExtents,
  1418.     _XmbGenericDrawString,
  1419.     _XmbGenericDrawImageString,
  1420.     _XwcGenericTextEscapement,
  1421.     _XwcGenericTextExtents,
  1422.     _XwcGenericTextPerCharExtents,
  1423.     _XwcGenericDrawString,
  1424.     _XwcGenericDrawImageString
  1425. };
  1426.  
  1427. typedef struct _XOCMethodsListRec {
  1428.     char *name;
  1429.     XOCMethods methods;
  1430. } XOCMethodsListRec, *XOCMethodsList;
  1431.  
  1432. static XOCMethodsListRec oc_methods_list[] = {
  1433.     { "default", &oc_default_methods },
  1434.     { "generic", &oc_generic_methods }
  1435. };
  1436.  
  1437. static XlcResource oc_resources[] = {
  1438.     { XNBaseFontName, NULLQUARK, sizeof(char *),
  1439.       XOffsetOf(XOCRec, core.base_name_list), XlcCreateMask | XlcGetMask },
  1440.     { XNOMAutomatic, NULLQUARK, sizeof(Bool),
  1441.       XOffsetOf(XOCRec, core.om_automatic), XlcGetMask },
  1442.     { XNMissingCharSet, NULLQUARK, sizeof(XOMCharSetList),
  1443.       XOffsetOf(XOCRec, core.missing_list), XlcGetMask },
  1444.     { XNDefaultString, NULLQUARK, sizeof(char *),
  1445.       XOffsetOf(XOCRec, core.default_string), XlcGetMask },
  1446.     { XNOrientation, NULLQUARK, sizeof(XOrientation),
  1447.       XOffsetOf(XOCRec, core.orientation), XlcDefaultMask | XlcSetMask | XlcGetMask },
  1448.     { XNResourceName, NULLQUARK, sizeof(char *),
  1449.       XOffsetOf(XOCRec, core.res_name), XlcSetMask | XlcGetMask },
  1450.     { XNResourceClass, NULLQUARK, sizeof(char *),
  1451.       XOffsetOf(XOCRec, core.res_class), XlcSetMask | XlcGetMask },
  1452.     { XNFontInfo, NULLQUARK, sizeof(XOMFontInfo),
  1453.       XOffsetOf(XOCRec, core.font_info), XlcGetMask }
  1454. };
  1455.  
  1456. static XOC
  1457. create_oc(om, args, num_args)
  1458.     XOM om;
  1459.     XlcArgList args;
  1460.     int num_args;
  1461. {
  1462.     DBUG_ENTER("create_oc")
  1463.     XOC oc;
  1464.     XOMGenericPart *gen = XOM_GENERIC(om);
  1465.     XOCMethodsList methods_list = oc_methods_list;
  1466.     int count;
  1467.  
  1468.     oc = (XOC) Xmalloc(sizeof(XOCGenericRec));
  1469.     if (oc == NULL)
  1470.     DBUG_RETURN((XOC) NULL);
  1471.     bzero((char *) oc, sizeof(XOCGenericRec));
  1472.     
  1473.     oc->core.om = om;
  1474.  
  1475.     if (oc_resources[0].xrm_name == NULLQUARK)
  1476.     _XlcCompileResourceList(oc_resources, XlcNumber(oc_resources));
  1477.     
  1478.     if (_XlcSetValues((XPointer) oc, oc_resources, XlcNumber(oc_resources),
  1479.               args, num_args, XlcCreateMask | XlcDefaultMask))
  1480.     goto err;
  1481.  
  1482.     if (oc->core.base_name_list == NULL)
  1483.     goto err;
  1484.  
  1485.     oc->core.resources = oc_resources;
  1486.     oc->core.num_resources = XlcNumber(oc_resources);
  1487.  
  1488.     if (create_fontset(oc) == False)
  1489.     goto err;
  1490.  
  1491.     oc->methods = &oc_generic_methods;
  1492.  
  1493.     if (gen->object_name) {
  1494.     count = XlcNumber(oc_methods_list);
  1495.  
  1496.     for ( ; count-- > 0; methods_list++) {
  1497.         if (!_XlcCompareISOLatin1(gen->object_name, methods_list->name)) {
  1498.         oc->methods = methods_list->methods;
  1499.         break;
  1500.         }
  1501.     }
  1502.     }
  1503.  
  1504.     DBUG_RETURN(oc);
  1505.  
  1506. err:
  1507.     destroy_oc(oc);
  1508.  
  1509.     DBUG_RETURN((XOC) NULL);
  1510. }
  1511.  
  1512. static void
  1513. free_fontdataOM(font_data, font_data_count)
  1514.     FontData    font_data;
  1515.     int        font_data_count;
  1516. {
  1517.     DBUG_ENTER("free_fontdataOM")
  1518.     for( ; font_data_count-- ; font_data++) {
  1519.     if(font_data->name){
  1520.         Xfree(font_data->name);
  1521.         font_data->name = NULL;
  1522.     }
  1523.     if(font_data->scopes){
  1524.         Xfree(font_data->scopes);
  1525.         font_data->scopes = NULL;
  1526.     }
  1527.     }
  1528.     DBUG_VOID_RETURN;
  1529. }
  1530.  
  1531. static Status
  1532. close_om(om)
  1533.     XOM om;
  1534. {
  1535.     DBUG_ENTER("close_om")
  1536.     XOMGenericPart *gen = XOM_GENERIC(om);
  1537.     OMData data;
  1538.     int count;
  1539.  
  1540.     if (data = gen->data) {
  1541.     for (count = gen->data_num; count-- > 0; data++) {
  1542.         if (data->charset_list){
  1543.         Xfree(data->charset_list);
  1544.         data->charset_list = NULL;
  1545.         }
  1546.         /* free font_data for om */
  1547.         if (data->font_data) {
  1548.         free_fontdataOM(data->font_data,data->font_data_count);
  1549.         Xfree(data->font_data);
  1550.         data->font_data = NULL;
  1551.         }
  1552.         /* free substitute for om */
  1553.         if (data->substitute) {
  1554.         free_fontdataOM(data->substitute,data->substitute_num);
  1555.         Xfree(data->substitute);
  1556.         data->substitute = NULL;
  1557.         }
  1558.         /* free vmap for om */
  1559.         if (data->vmap) {
  1560.         free_fontdataOM(data->vmap,data->vmap_num);
  1561.         Xfree(data->vmap);
  1562.         data->vmap = NULL;
  1563.         }
  1564.         /* free vrotate for om */
  1565.         if (data->vrotate) {
  1566.         Xfree(data->vrotate);
  1567.         data->vrotate = NULL;
  1568.         }
  1569.     }
  1570.     Xfree(gen->data);
  1571.     gen->data = NULL;
  1572.     }
  1573.  
  1574.     if (gen->object_name){
  1575.     Xfree(gen->object_name);
  1576.     gen->object_name = NULL;
  1577.     }
  1578.  
  1579.     if (om->core.res_name){
  1580.     Xfree(om->core.res_name);
  1581.     om->core.res_name = NULL;
  1582.     }
  1583.     if (om->core.res_class){
  1584.     Xfree(om->core.res_class);
  1585.     om->core.res_class = NULL;
  1586.     }
  1587.     if (om->core.required_charset.charset_list &&
  1588.     om->core.required_charset.charset_count > 0){
  1589.     XFreeStringList(om->core.required_charset.charset_list);
  1590.     om->core.required_charset.charset_list = NULL;
  1591.     } else {
  1592.     Xfree((char*)om->core.required_charset.charset_list);
  1593.     om->core.required_charset.charset_list = NULL;
  1594.     }
  1595.     if (om->core.orientation_list.orientation){
  1596.     Xfree(om->core.orientation_list.orientation);
  1597.     om->core.orientation_list.orientation = NULL;
  1598.     }
  1599.  
  1600.     Xfree(om);
  1601.  
  1602.     DBUG_RETURN(1);
  1603. }
  1604.  
  1605. static char *
  1606. set_om_values(om, args, num_args)
  1607.     XOM om;
  1608.     XlcArgList args;
  1609.     int num_args;
  1610. {
  1611.     DBUG_ENTER("set_om_values")
  1612.     char *result;
  1613.     if (om->core.resources == NULL)
  1614.     DBUG_RETURN(NULL);
  1615.  
  1616.     result = _XlcSetValues((XPointer) om, om->core.resources,
  1617.              om->core.num_resources, args, num_args, XlcSetMask);
  1618.     DBUG_RETURN(result);
  1619. }
  1620.  
  1621. static char *
  1622. get_om_values(om, args, num_args)
  1623.     XOM om;
  1624.     XlcArgList args;
  1625.     int num_args;
  1626. {
  1627.     DBUG_ENTER("get_om_values")
  1628.     char *result;
  1629.     if (om->core.resources == NULL)
  1630.     DBUG_RETURN(NULL);
  1631.  
  1632.     result = _XlcGetValues((XPointer) om, om->core.resources,
  1633.              om->core.num_resources, args, num_args, XlcGetMask);
  1634.     DBUG_RETURN(result);
  1635. }
  1636.  
  1637. static XOMMethodsRec methods = {
  1638.     close_om,
  1639.     set_om_values,
  1640.     get_om_values,
  1641.     create_oc
  1642. };
  1643.  
  1644. static XlcResource om_resources[] = {
  1645.     { XNRequiredCharSet, NULLQUARK, sizeof(XOMCharSetList),
  1646.       XOffsetOf(XOMRec, core.required_charset), XlcGetMask },
  1647.     { XNQueryOrientation, NULLQUARK, sizeof(XOMOrientation),
  1648.       XOffsetOf(XOMRec, core.orientation_list), XlcGetMask },
  1649.     { XNDirectionalDependentDrawing, NULLQUARK, sizeof(Bool),
  1650.       XOffsetOf(XOMRec, core.directional_dependent), XlcGetMask },
  1651.     { XNContextualDrawing, NULLQUARK, sizeof(Bool),
  1652.       XOffsetOf(XOMRec, core.contextual_drawing), XlcGetMask }
  1653. };
  1654.  
  1655. static XOM
  1656. create_om(lcd, dpy, rdb, res_name, res_class)
  1657.     XLCd lcd;
  1658.     Display *dpy;
  1659.     XrmDatabase rdb;
  1660.     char *res_name;
  1661.     char *res_class;
  1662. {
  1663.     DBUG_ENTER("create_om")
  1664.     XOM om;
  1665.  
  1666.     om = (XOM) Xmalloc(sizeof(XOMGenericRec));
  1667.     if (om == NULL)
  1668.     DBUG_RETURN((XOM) NULL);
  1669.     bzero((char *) om, sizeof(XOMGenericRec));
  1670.     
  1671.     om->methods = &methods;
  1672.     om->core.lcd = lcd;
  1673.     om->core.display = dpy;
  1674.     om->core.rdb = rdb;
  1675.     if (res_name) {
  1676.     om->core.res_name = (char *) Xmalloc(strlen(res_name) + 1);
  1677.     if (om->core.res_name == NULL)
  1678.         goto err;
  1679.     strcpy(om->core.res_name, res_name);
  1680.     }
  1681.     if (res_class) {
  1682.     om->core.res_class = (char *) Xmalloc(strlen(res_class) + 1);
  1683.     if (om->core.res_class == NULL)
  1684.         goto err;
  1685.     strcpy(om->core.res_class, res_class);
  1686.     }
  1687.  
  1688.     if (om_resources[0].xrm_name == NULLQUARK)
  1689.     _XlcCompileResourceList(om_resources, XlcNumber(om_resources));
  1690.     
  1691.     om->core.resources = om_resources;
  1692.     om->core.num_resources = XlcNumber(om_resources);
  1693.  
  1694.     DBUG_RETURN(om);
  1695.  
  1696. err:
  1697.     close_om(om);
  1698.  
  1699.     DBUG_RETURN((XOM) NULL);
  1700. }
  1701.  
  1702. static OMData
  1703. add_data(om)
  1704.     XOM om;
  1705. {
  1706.     DBUG_ENTER("add_data")
  1707.     XOMGenericPart *gen = XOM_GENERIC(om);
  1708.     OMData new;
  1709.     int num;
  1710.  
  1711.     if (num = gen->data_num)
  1712.         new = (OMData) Xrealloc(gen->data, (num + 1) * sizeof(OMDataRec));
  1713.     else
  1714.         new = (OMData) Xmalloc(sizeof(OMDataRec));
  1715.  
  1716.     if (new == NULL)
  1717.         DBUG_RETURN(NULL);
  1718.  
  1719.     gen->data_num = num + 1;
  1720.     gen->data = new;
  1721.  
  1722.     new += num;
  1723.     bzero((char *) new, sizeof(OMDataRec));
  1724.  
  1725.     DBUG_RETURN(new);
  1726. }
  1727.  
  1728. /* For VW/UDC */
  1729.  
  1730. extern FontScope _XlcParse_scopemaps();
  1731.  
  1732. FontData
  1733. read_EncodingInfo(count,value)
  1734. int count;
  1735. char **value;
  1736. {
  1737.     DBUG_ENTER("read_EncodingInfo")
  1738.     FontData font_data,ret;
  1739.     char *buf, *bufptr,*scp;
  1740.     FontScope scope;
  1741.     int len;
  1742.     font_data = (FontData) Xmalloc(sizeof(FontDataRec) * count);
  1743.     if (font_data == NULL)
  1744.         DBUG_RETURN(NULL);
  1745.     bzero((char *) font_data, sizeof(FontDataRec) * count);
  1746.  
  1747.     ret = font_data;
  1748.     for ( ; count-- > 0; font_data++) {
  1749. /*
  1750.         strcpy(buf, *value++);
  1751. */
  1752.     buf = *value; value++;
  1753.         if (bufptr = strchr(buf, ':')){
  1754.         len = (int)(bufptr - buf);
  1755.             bufptr++ ;
  1756.     }
  1757.         font_data->name = (char *) Xmalloc(len + 1);
  1758.         if (font_data->name == NULL)
  1759.             DBUG_RETURN(NULL);
  1760.         strncpy(font_data->name, buf,len);
  1761.     font_data->name[len] = 0;
  1762.         if (bufptr && _XlcCompareISOLatin1(bufptr, "GL") == 0)
  1763.             font_data->side = XlcGL;
  1764.         else if (bufptr && _XlcCompareISOLatin1(bufptr, "GR") == 0)
  1765.             font_data->side = XlcGR;
  1766.         else
  1767.             font_data->side = XlcGLGR;
  1768.  
  1769.         if (bufptr && (scp = strchr(bufptr, '['))){
  1770.             font_data->scopes = _XlcParse_scopemaps(scp,&(font_data->scopes_num));
  1771.         }
  1772.     }
  1773.     DBUG_RETURN(ret);
  1774. }
  1775.  
  1776. static CodeRange read_vrotate(count,value,type,vrotate_num)
  1777. int count;
  1778. char **value;
  1779. int *type;
  1780. int *vrotate_num;
  1781. {
  1782.     DBUG_ENTER("read_vrotate")
  1783.     FontData font_data,ret;
  1784.     char *buf, *bufptr,*scp;
  1785.     CodeRange   range;
  1786.     if(!strcmp(value[0],"all")){
  1787.     *type          = VROTATE_ALL ;
  1788.     *vrotate_num = 0 ;
  1789.     DBUG_RETURN(NULL);
  1790.     } else if(*(value[0]) == '['){
  1791.     *type          = VROTATE_PART ;
  1792.         range = (CodeRange) _XlcParse_scopemaps(value[0],vrotate_num);
  1793.     DBUG_RETURN(range);
  1794.     } else {
  1795.     *type          = VROTATE_NONE ;
  1796.     *vrotate_num = 0 ;
  1797.     DBUG_RETURN(NULL);
  1798.     }
  1799. }
  1800.  
  1801. static void read_vw(lcd,font_set,num)
  1802. XLCd    lcd;
  1803. OMData  font_set;
  1804. int num;
  1805. {
  1806.     DBUG_ENTER("read_vw")
  1807.     char **value, buf[BUFSIZ], *bufptr;
  1808.     int count,i;
  1809.  
  1810.     sprintf(buf, "fs%d.font.vertical_map", num);
  1811.     _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1812.     if (count > 0){
  1813.         _XlcDbg_printValue(buf,value,count);
  1814.         font_set->vmap_num = count;
  1815.         font_set->vmap = read_EncodingInfo(count,value);
  1816.     }
  1817.  
  1818.     sprintf(buf, "fs%d.font.vertical_rotate", num);
  1819.     _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1820.     if (count > 0){
  1821.         _XlcDbg_printValue(buf,value,count);
  1822.         font_set->vrotate = read_vrotate(count,value,&(font_set->vrotate_type),
  1823.                 &(font_set->vrotate_num));
  1824.     }
  1825.     DBUG_VOID_RETURN;
  1826. }
  1827. /* VW/UDC end */
  1828. static Bool
  1829. init_om(om)
  1830.     XOM om;
  1831. {
  1832.     DBUG_ENTER("init_om")
  1833.     XLCd lcd = om->core.lcd;
  1834.     XOMGenericPart *gen = XOM_GENERIC(om);
  1835.     OMData data;
  1836.     XlcCharSet *charset_list;
  1837.     FontData font_data;
  1838.     char **required_list;
  1839.     XOrientation *orientation;
  1840.     char **value, buf[BUFSIZ], *bufptr;
  1841.     int count = 0, num = 0, length = 0;
  1842.  
  1843.     _XlcGetResource(lcd, "XLC_FONTSET", "on_demand_loading", &value, &count);
  1844.     if (count > 0 && _XlcCompareISOLatin1(*value, "True") == 0)
  1845.     gen->on_demand_loading = True;
  1846.  
  1847.     _XlcGetResource(lcd, "XLC_FONTSET", "object_name", &value, &count);
  1848.     if (count > 0) {
  1849.     gen->object_name = (char *) Xmalloc(strlen(*value) + 1);
  1850.     if (gen->object_name == NULL)
  1851.         DBUG_RETURN(False);
  1852.     strcpy(gen->object_name, *value);
  1853.     }
  1854.  
  1855.     for (num = 0; ; num++) {
  1856.  
  1857.         sprintf(buf, "fs%d.charset.name", num);
  1858.         _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1859.  
  1860.         if( count < 1){
  1861.             sprintf(buf, "fs%d.charset", num);
  1862.             _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1863.             if (count < 1)
  1864.                 break;
  1865.         }
  1866.  
  1867.     data = add_data(om);
  1868.     if (data == NULL)
  1869.         DBUG_RETURN(False);
  1870.     
  1871.     charset_list = (XlcCharSet *) Xmalloc(sizeof(XlcCharSet) * count);
  1872.     if (charset_list == NULL)
  1873.         return False;
  1874.     data->charset_list = charset_list;
  1875.     data->charset_count = count;
  1876.  
  1877.     while (count-- > 0){
  1878.         *charset_list++ = _XlcGetCharSet(*value++);
  1879.         }
  1880.         sprintf(buf, "fs%d.charset.udc_area", num);
  1881.         _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1882.         if( count > 0){
  1883.             UDCArea udc;
  1884.             int i,flag = 0;
  1885.             udc = (UDCArea)Xmalloc(count * sizeof(UDCAreaRec));
  1886.         if (udc == NULL)
  1887.             DBUG_RETURN(False);
  1888.             for(i=0;i<count;i++){
  1889.                 sscanf(value[i],"\\x%x,\\x%x", &(udc[i].start), &(udc[i].end));
  1890.             }
  1891.             for(i=0;i<data->charset_count;i++){
  1892.         if(data->charset_list[i]->udc_area == NULL){
  1893.             data->charset_list[i]->udc_area     = udc;
  1894.             data->charset_list[i]->udc_area_num = count;
  1895.             flag = 1;
  1896.         }
  1897.             }
  1898.         if(flag == 0){
  1899.         Xfree(udc);
  1900.         }
  1901.         }
  1902.  
  1903.         sprintf(buf, "fs%d.font.primary", num);
  1904.         _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1905.         if (count < 1){
  1906.             sprintf(buf, "fs%d.font", num);
  1907.             _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1908.             if (count < 1)
  1909.                 DBUG_RETURN(False);
  1910.         }
  1911.  
  1912.     font_data = read_EncodingInfo(count,value);
  1913.     if (font_data == NULL)
  1914.         DBUG_RETURN(False);
  1915.  
  1916.     data->font_data = font_data;
  1917.     data->font_data_count = count;
  1918.  
  1919.         sprintf(buf, "fs%d.font.substitute", num);
  1920.         _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1921.         if (count > 0){
  1922.             font_data = read_EncodingInfo(count,value);
  1923.             if (font_data == NULL)
  1924.             DBUG_RETURN(False);
  1925.             data->substitute      = font_data;
  1926.             data->substitute_num = count;
  1927.         } else {
  1928.             sprintf(buf, "fs%d.font", num);
  1929.             _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count);
  1930.             if (count < 1) {
  1931.                 data->substitute      = NULL;
  1932.                 data->substitute_num = 0;
  1933.         } else {
  1934.                 font_data = read_EncodingInfo(count,value);
  1935.                 data->substitute      = font_data;
  1936.                 data->substitute_num = count;
  1937.         }
  1938.     }
  1939.         read_vw(lcd,data,num);
  1940.     length += strlen(data->font_data->name) + 1;
  1941.     }
  1942.  
  1943.     /* required charset list */
  1944.     required_list = (char **) Xmalloc(sizeof(char *) * gen->data_num);
  1945.     if (required_list == NULL)
  1946.     DBUG_RETURN(False);
  1947.  
  1948.     bufptr = (char *) Xmalloc(length);
  1949.     if (bufptr == NULL) {
  1950.     Xfree(required_list);
  1951.     DBUG_RETURN(False);
  1952.     }
  1953.  
  1954.     om->core.required_charset.charset_list = required_list;
  1955.     om->core.required_charset.charset_count = gen->data_num;
  1956.  
  1957.     count = gen->data_num;
  1958.     data = gen->data;
  1959.  
  1960.     for ( ; count-- > 0; data++) {
  1961.     strcpy(bufptr, data->font_data->name);
  1962.     *required_list++ = bufptr;
  1963.     bufptr += strlen(bufptr) + 1;
  1964.     }
  1965.  
  1966.     /* orientation list */
  1967.     orientation = (XOrientation *) Xmalloc(sizeof(XOrientation) * 2);
  1968.     if (orientation == NULL)
  1969.     DBUG_RETURN(False);
  1970.  
  1971.     orientation[0] = XOMOrientation_LTR_TTB;
  1972.     orientation[1] = XOMOrientation_TTB_RTL;
  1973.     om->core.orientation_list.orientation = orientation;
  1974.     om->core.orientation_list.num_orientation = 2;
  1975.  
  1976.     /* directional dependent drawing */
  1977.     om->core.directional_dependent = False;
  1978.  
  1979.     /* contexual drawing */
  1980.     om->core.contextual_drawing = False;
  1981.  
  1982.     /* context dependent */
  1983.     om->core.context_dependent = False;
  1984.  
  1985.     DBUG_RETURN(True);
  1986. }
  1987.  
  1988. XOM
  1989. #if NeedFunctionPrototypes
  1990. _XomGenericOpenOM(XLCd lcd, Display *dpy, XrmDatabase rdb,
  1991.           _Xconst char *res_name, _Xconst char *res_class)
  1992. #else
  1993. _XomGenericOpenOM(lcd, dpy, rdb, res_name, res_class)
  1994.     XLCd lcd;
  1995.     Display *dpy;
  1996.     XrmDatabase rdb;
  1997.     char *res_name;
  1998.     char *res_class;
  1999. #endif
  2000. {
  2001.     DBUG_ENTER("_XomGenericOpenOM")
  2002.     XOM om;
  2003.  
  2004.     om = create_om(lcd, dpy, rdb, res_name, res_class);
  2005.     if (om == NULL)
  2006.     DBUG_RETURN((XOM) NULL);
  2007.     
  2008.     if (init_om(om) == False)
  2009.     goto err;
  2010.  
  2011.     DBUG_RETURN(om);
  2012.  
  2013. err:
  2014.     close_om(om);
  2015.  
  2016.     DBUG_RETURN((XOM) NULL);
  2017. }
  2018.  
  2019. Bool
  2020. _XInitOM(lcd)
  2021.     XLCd lcd;
  2022. {
  2023.     DBUG_ENTER("_XInitOM")
  2024.     lcd->methods->open_om = _XomGenericOpenOM;
  2025.  
  2026.     DBUG_RETURN(True);
  2027. }
  2028.