cde/programs/dtudcexch/selectx.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* selectx.c 1.12 - Fujitsu source for CDEnext    96/03/01 09:34:52      */
  24 /* $TOG: selectx.c /main/5 1997/07/23 17:24:39 samborn $ */
  25 /*
  26  *  (c) Copyright 1995 FUJITSU LIMITED
  27  *  This is source code modified by FUJITSU LIMITED under the Joint
  28  *  Development Agreement for the CDEnext PST.
  29  *  This is unpublished proprietary source code of FUJITSU LIMITED
  30  */
  31
  32
  33 #include <string.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <locale.h> /* dtex add */
  37 #include <math.h> /* dtex add */
  38 #include <nl_types.h>
  39
  40 #include<X11/Xlib.h>
  41 #include<X11/Xutil.h>
  42 #include<X11/Xatom.h>
  43
  44 #include <Xm/Xm.h>
  45 #include <Xm/Form.h>
  46 #include <Xm/PushB.h>
  47 #include <Xm/Text.h>
  48 #include <Xm/TextF.h>
  49 #include <Xm/Label.h>
  50 #include <Xm/SeparatoG.h>
  51 #include <Xm/List.h>
  52 #include <Xm/ToggleB.h>
  53 #include <Xm/MessageB.h>
  54 #include <Xm/RowColumn.h>
  55 #include <Xm/Frame.h>
  56 #include <Xm/Label.h>
  57
  58
  59 #include "xoakufont.h"
  60 #include "selectxlfd.h"
  61 #include "excutil.h" /* dtex add */
  62
  63 /*
  64  * There is no public header file for this function (only an
  65  * internal header XmStringI.h).
  66  */
  67 extern XtPointer _XmStringUngenerate (XmString string,
  68                         XmStringTag tag,
  69                         XmTextType tag_type,
  70                         XmTextType output_type);
  71
  72 /*extern Resource       resource ; dtex del*/
  73 /* dtex add */
  74 extern Exc_data *ed;
  75 extern ListData *ld;
  76 FalGlyphRegion  *gr;
  77 int num_gr;
  78 FalFontID               fid;
  79 extern char *maintitle;
  80 extern char **errmsg_org;
  81
  82 /*
  83  * parameters
  84  */
  85
  86 FalFontData fullFontData;
  87
  88 void    PopupSelectXLFD() ;
  89 static Widget   CreateSelectXLFD() ;
  90
  91 /*extern        void    xlfdPopupDialog() ; dtex del*/
  92 extern  int     GetListsOfItems() ;
  93
  94 /* extern       void    ReadCB(); dtex del */
  95
  96 Widget  xlfdDialog;
  97 static Widget xlfdWform;
  98
  99 #define CS0 "Codeset 0"
 100 #define CS1 "Codeset 1"
 101 #define CS2 "Codeset 2"
 102 #define CS3 "Codeset 3"
 103
 104 #define ERROR_1 errmsg_org[fal_utyerrno & 0xff]
 105 /*#define ERROR_1 fal_errmsg_org[fal_utyerrno & 0xff]*/
 106 /*#define ERROR_2 fal_errmsg_func[fal_utyerrno >>8]*/
 107
 108 static Widget   pull1, pull2, pull3, pull4, scrolllist;
 109 static int      xlf_count = 0;
 110 static XmString *xlf=NULL;
 111 static int      udc_count = 0;
 112 static Boolean  udc_flag = False;
 113 static int      *udc=NULL;
 114 static int      udc_val;
 115 static int      sty_count = 0;
 116 static Boolean  sty_flag = False;
 117 static char     **sty=NULL;
 118 static char     *sty_val=NULL;
 119 static int      wls_count = 0;
 120 static Boolean  wls_flag = False;
 121 static int      *wls=NULL;
 122 static int      wls_val;
 123 static int      hls_count = 0;
 124 static Boolean  hls_flag = False;
 125 static int      *hls=NULL;
 126 static int      hls_val;
 127 static Widget       *button1=NULL;
 128 static Widget       *button2=NULL;
 129 static Widget       *button3=NULL;
 130 static Widget       *button4=NULL;
 131
 132 /*
 133  * util dtex
 134  */
 135
 136 void
 137 xlfdPopupDialog(w)
 138 Widget w;
 139 {
 140     if (! XtIsManaged(w))
 141         XtManageChild(w);
 142     else
 143         XRaiseWindow(XtDisplayOfObject(w), XtWindow(XtParent(w)));
 144 }
 145
 146 void
 147 ForcePopdownDialog(w)
 148 Widget w;
 149 {
 150     if (XtIsManaged(w)){
 151         XtUnmanageChild(w);
 152     }
 153 }
 154
 155 int fontcheck(char *mode)
 156 /*
 157  * If fontfile can't be opend, return -1.
 158  * If fontfile is editted by other UDC client, return 1.
 159  * normary return 0.
 160  */
 161 {
 162     int mask;
 163     FalFontDataList     *fulllist = NULL;
 164     FalFontID           fontid;
 165
 166     mask =  FAL_FONT_MASK_XLFDNAME | FAL_FONT_MASK_GLYPH_INDEX |
 167             FAL_FONT_MASK_DEFINED |
 168             FAL_FONT_MASK_UNDEFINED | FAL_FONT_MASK_CODE_SET;
 169
 170     if (strcmp(mode, "w") == 0)
 171         mask |= FAL_FONT_MASK_UPDATE;
 172
 173     fontid = FalOpenSysFont(&fullFontData, mask, &fulllist);
 174     if (fontid == 0) {
 175         if ((fal_utyerrno & 0xff) == 0x10)/*_FAL_ERR_LCKD*/
 176             return (1);
 177         return (-1);
 178     }
 179
 180     FalCloseFont( fontid );
 181     return (0);
 182 }
 183
 184 void setallcode(ListData *ld)
 185 {
 186     int         i, code, codenum;
 187     int         *codep;
 188     int         code1, code2;
 189
 190     codenum = 0;
 191     for (i = 0; i < num_gr; i++) {
 192         codenum += (abs(gr[i].end - gr[i].start) + 1);
 193     }
 194
 195     ld->allcode = (int *) calloc(codenum, sizeof(int));
 196     ld->allcode_num = codenum;
 197     codep = ld->allcode;
 198     for (i = 0; i < num_gr; i++) {
 199         code1 = smaller(gr[i].start, gr[i].end);
 200         code2 = bigger(gr[i].start, gr[i].end);
 201         for (code = code1; code <= code2; code++) {
 202             *codep = code;
 203             codep++;
 204         }
 205     }
 206 }
 207
 208 FalFontID openfont()
 209 {
 210     int mask;
 211     FalFontDataList     *fulllist = NULL;
 212     FalFontID           fontid;
 213     char                        *fullpath=NULL;
 214
 215     mask =  FAL_FONT_MASK_XLFDNAME | FAL_FONT_MASK_GLYPH_INDEX |
 216             FAL_FONT_MASK_DEFINED |
 217             FAL_FONT_MASK_UNDEFINED | FAL_FONT_MASK_CODE_SET;
 218     fontid = FalOpenSysFont(&fullFontData, mask, &fulllist);
 219     if (fontid == 0) {
 220         return ( 0 );
 221     }
 222     if (fullpath != NULL)
 223         FalFree(fullpath);
 224     if (FalFontIDToFileName(fontid, &fullpath) < 0){
 225         FalCloseFont(fontid);
 226         fontid = NULL;
 227     }
 228     if ((ed->fontfile = strdup(fullpath)) == NULL) {
 229         exit (-1);
 230     }
 231     return (fontid);
 232 }
 233
 234 void makelist(ListData *ld)
 235 {
 236     char        *pattern;
 237     int         code;
 238     int         *existcodep, *allcodep;
 239     int         existcode_num;
 240     int         i;
 241
 242     ld->existcode = (int *) calloc(ld->allcode_num, sizeof(int));
 243     existcodep = ld->existcode ;
 244     allcodep = ld->allcode;
 245     existcode_num = 0;
 246     for (i = 0; i < ld->allcode_num; i++) {
 247         code = *allcodep;
 248         pattern = FalReadFont(fid, code, NULL, NULL);
 249         if (fal_utyexists == 0) {
 250             *existcodep = *allcodep;
 251             existcodep++;
 252             existcode_num++;
 253         }
 254         allcodep++;
 255     }
 256     ld->existcode_num = existcode_num;
 257 }
 258
 259 void setexistcode(ListData *ld)
 260 {
 261     fid = openfont();
 262
 263     makelist(ld);
 264
 265 /* close font */
 266     if (fid != NULL)
 267         FalCloseFont(fid);
 268 }
 269
 270
 271 char i2c(int num)
 272 {
 273     char c;
 274
 275     if ((0 <= num) && (num <= 9))
 276         c = '0' + num;
 277     else if ((10 <= num) && (num <= 15))
 278         c = 'a' + (num - 10);
 279     else
 280         fprintf(stderr,"error in i2c\n");
 281     return c;
 282 }
 283
 284 char *i2s(int code)
 285 {
 286     char        buf[8];
 287     char        *number;
 288     char        *cp;
 289     int         i;
 290     int         tmp;
 291     int         len;
 292
 293     tmp = code;
 294     for (i = 0; ; i++) {
 295         if (tmp < 16) {
 296             buf[i] = i2c(tmp);
 297             buf[i+1] = NULL;
 298             break;
 299         }
 300         buf[i] = i2c(tmp % 16);
 301         tmp = tmp / 16;
 302     }
 303     len = strlen(buf);
 304     number = (char *) calloc(len+3, sizeof(char));
 305     cp = number;
 306     memcpy(cp, "0x", 2);
 307     cp += 2;
 308     for (i = len - 1; i >= 0; i--) {
 309         *cp = buf[i];
 310         cp++;
 311     }
 312     *cp = NULL;
 313     return (number);
 314 }
 315
 316 void setexistcode_c(ListData *ld)
 317 {
 318     int         i;
 319     char        **code_cp;
 320     int         *codep;
 321
 322     if (ld->existcode_num == 0) {
 323         return;
 324     }
 325
 326     ld->existcode_c = (char **) calloc(ld->existcode_num, sizeof(char *));
 327     code_cp = ld->existcode_c;
 328     codep = ld->existcode;
 329     for (i = 0; i < ld->existcode_num; i++) {
 330         *code_cp = i2s(*codep);
 331         code_cp++;
 332         codep++;
 333     }
 334 }
 335
 336 void getexistcode(ListData *ld)
 337 {
 338     setallcode(ld);
 339     setexistcode(ld);
 340     setexistcode_c(ld);
 341 }
 342
 343 /****************************************************************
 344  * callbacks                                                    *
 345  ***************************************************************/
 346
 347 void quit(w, client_data, call_data) /* dtex */
 348 Widget  w;
 349 caddr_t *client_data, *call_data;
 350 {
 351     excterminate(ed);
 352 }
 353
 354 static char *
 355 char_set(char *str) /* dtex */
 356 {
 357     int i, count;
 358     char *p;
 359     for (i=strlen(str),p=&(str[i]),count=0; i && count < 2; i--,p--) {
 360         if (*p == '-')
 361             count ++;
 362     }
 363     if (count == 2)
 364         return(p + 2);
 365     else
 366         return(str);
 367 }
 368
 369 static char *
 370 spc(str, ch, count)
 371 char *  str;
 372 char    ch;
 373 int     count;
 374 {
 375     char *p;
 376     p = str + strlen(str);
 377     for(;count && (str < p);p--) {
 378         if (*p == ch)
 379             count --;
 380     }
 381     if (! count)
 382         return(p+1);
 383     else
 384         return(NULL);
 385 }
 386
 387 static void OpenWindowCB() /* dtex change */
 388 {
 389     char        *str, *p;
 390     XmStringTable       st;
 391     /*dtex add */
 392     int r;
 393     int         ans;
 394     char        *msg;
 395     char        *msg2;
 396     char        *msg3;
 397     char        err[128];
 398     extern void selcharcd();
 399     char *locale;
 400     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED
 401         | FAL_FONT_MASK_XLFDNAME;
 402     FalFontData key;
 403     FalFontDataList *fontlist;
 404     FalFontData *f;
 405
 406     msg = GETMESSAGE(4, 2, "This font has no user defined characters.");
 407     msg2 = GETMESSAGE(4, 4, "Failed to open the selected font. You have no right to access for the font file, or the format of the file is not consistent.");
 408     msg3 = GETMESSAGE(4, 6, "The font file is used by other UDC client.");
 409
 410     XtVaGetValues(scrolllist, XmNselectedItems, &st, NULL);
 411     if( st == NULL ){
 412         return ;
 413     }
 414     str = (char *) _XmStringUngenerate((XmString) st[0],
 415                                  NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 416     if ( str == NULL ) {
 417         return;
 418     }
 419
 420     p = spc(str, '-', 4);
 421     p++;
 422
 423     if (*p == 'p' || *p == 'P') {
 424         str = NULL;
 425     }
 426
 427     fullFontData.xlfdname = str;
 428     if ((ed->xlfdname = strdup(str)) == NULL) {
 429         exit (-1);
 430     }
 431     if(udc_flag == True)
 432         fullFontData.cd_set = udc_val;
 433     else { /* dtex change */
 434         memset(&key, 0x00, sizeof(FalFontData));
 435         key.xlfdname = fullFontData.xlfdname;
 436         if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR)
 437             return;
 438         if (fontlist->num != 1)
 439             return;
 440         f = fontlist->list;
 441         /*fullFontData.cd_set = -1;*/
 442         fullFontData.cd_set = f->cd_set;
 443         FalFreeFontList(fontlist);
 444     }
 445
 446     if (ld != NULL) {
 447         freeld(ld);
 448     }
 449
 450     if ((ld = (ListData *) malloc(sizeof(ListData))) == NULL) {
 451         excerror(ed, EXCERRMALLOC, "selcharcd", "exit");
 452     }
 453     memset(ld, 0x00, sizeof(ListData));
 454     ld->ed = ed;
 455     locale = getenv("LANG");
 456     if (locale == NULL)
 457         locale = "C";
 458     if (FalGetUDCGIArea(locale, fullFontData.cd_set,
 459                         char_set(fullFontData.xlfdname), &gr, &num_gr)
 460         == FAL_ERROR) {
 461             fprintf(stderr, "error in FalGetUDCGIArea\n");
 462             sprintf(err, "%s", ERROR_1);
 463             AskUser(ed->toplevel, ed, err, &ans, "error");
 464             return;
 465     }
 466     if (ed->function == EXPORT) {
 467         r = fontcheck("r");
 468         if (r == -1) { /* file open error */
 469             AskUser(ld->ed->toplevel, ld->ed, msg2, &ans, "error");
 470             return;
 471         } else if (r == 1) { /* file is being editted by other UDC client */
 472             AskUser(ld->ed->toplevel, ld->ed, msg3, &ans, "error");
 473             return;
 474         }
 475         /* get existing UDC code */
 476         getexistcode(ld);
 477         if (ld->existcode_num == 0) {
 478             AskUser(ld->ed->toplevel, ld->ed, msg, &ans, "error");
 479             return;
 480         }
 481         XtUnmanageChild(xlfdDialog);
 482         selcharcd(ld->ed);
 483     } else if (ed->function == IMPORT) {
 484         r = fontcheck("w");
 485         if (r == -1) { /* file open error */
 486             AskUser(ld->ed->toplevel, ld->ed, msg2, &ans, "error");
 487             return;
 488         } else if (r == 1) { /* file is being editted by other UDC client */
 489             AskUser(ld->ed->toplevel, ld->ed, msg3, &ans, "error");
 490             return;
 491         }
 492         /* get existing UDC code */
 493         getexistcode(ld);
 494
 495         XtUnmanageChild(xlfdDialog);
 496         getcharcd(ed);
 497     }
 498 }
 499
 500 /**
 501  **  contents : "Cancel" button callback
 502  ** ------------------------
 503  **
 504  **
 505  **/
 506
 507 /*ARGSUSED*/
 508 static void
 509 OpenCancelCB( widget, clientData, callData ) /* dtex change */
 510 Widget          widget;
 511 caddr_t         clientData;
 512 caddr_t         callData;
 513 {
 514 /*    extern void ForcePopdownDialog();
 515     if ( !editPtnW ){
 516         exit( 0 );
 517     } dtex del */
 518     ForcePopdownDialog(xlfdDialog);
 519 }
 520
 521
 522 /*
 523 * create selection window view
 524 */
 525 void
 526 PopupSelectXLFD( top )
 527 Widget  top ;
 528 {
 529
 530     if( xlfdDialog == NULL ){
 531         if( (xlfdDialog = CreateSelectXLFD( top )) == NULL ){
 532             exit( -1 ) ;
 533         }
 534     }
 535     /* pop up select window */
 536     xlfdPopupDialog( xlfdDialog );
 537 }
 538
 539
 540 static void
 541 create_xlfd()
 542 {
 543         int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 544         FalFontData key;
 545         FalFontDataList *fontlist;
 546         FalFontData *f;
 547         int i;
 548
 549         if (udc_flag == True) {
 550                 key.cd_set = udc_val;
 551                 mask |= FAL_FONT_MASK_CODE_SET;
 552         }
 553         if (sty_flag == True) {
 554                 key.style.name = sty_val;
 555                 mask |= FAL_FONT_MASK_STYLE_NAME;
 556         }
 557         if (wls_flag == True) {
 558                 key.size.w = wls_val;
 559                 mask |= FAL_FONT_MASK_SIZE_W;
 560         }
 561         if (hls_flag == True) {
 562                 key.size.h = hls_val;
 563                 mask |= FAL_FONT_MASK_SIZE_H;
 564         }
 565         xlf_count = 0;
 566         if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 567                 return;
 568         }
 569         if(fontlist->num == 0) {
 570                 FalFreeFontList(fontlist);
 571                 return;
 572         }
 573         if (xlf) {
 574             for (i=0; i < xlf_count; i++) {
 575                 XmStringFree(xlf[i]);
 576             }
 577             XtFree((char *)xlf);
 578         }
 579         xlf = (XmString *)XtMalloc(sizeof(XmString) * fontlist->num);
 580         for (i=0, f=fontlist->list; i < fontlist->num; i++, f++) {
 581             xlf[xlf_count++] = XmStringCreateLocalized(f->xlfdname);
 582         }
 583         FalFreeFontList(fontlist);
 584 }
 585
 586 static void
 587 udc_call(w)
 588 Widget w;
 589 {
 590         XmString label;
 591         char *moji;
 592
 593         XtVaGetValues(w, XmNlabelString, &label, NULL);
 594
 595         moji = (char *) _XmStringUngenerate((XmString) label, NULL,
 596                                         XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 597         if (moji) {
 598               if(strncmp(moji, "*", 1) == 0) {
 599                       udc_flag = False;
 600               } else if(strcmp(moji, CS0) == 0) {
 601                       udc_val = FAL_FONT_CS0;
 602                       udc_flag = True;
 603               } else if(strcmp(moji, CS1) == 0) {
 604                       udc_val = FAL_FONT_CS1;
 605                       udc_flag = True;
 606               } else if(strcmp(moji, CS2) == 0) {
 607                       udc_val = FAL_FONT_CS2;
 608                       udc_flag = True;
 609               } else if(strcmp(moji, CS3) == 0) {
 610                       udc_val = FAL_FONT_CS3;
 611                       udc_flag = True;
 612               } else {
 613                       udc_flag = False;
 614               }
 615               XtFree(moji);
 616         } else {
 617                       udc_flag = False;
 618         }
 619         create_xlfd();
 620         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 621 }
 622
 623 static void
 624 sty_call(w)
 625 Widget w;
 626 {
 627         XmString label;
 628         char *moji;
 629         if (sty_val) {
 630                 XtFree(sty_val);
 631                 sty_val = NULL;
 632         }
 633         XtVaGetValues(w, XmNlabelString, &label, NULL);
 634
 635         moji = (char *) _XmStringUngenerate((XmString) label, NULL,
 636                                         XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 637         if (moji) {
 638               if(strncmp(moji, "*", 1) == 0) {
 639                       sty_flag = False;
 640               }
 641               else {
 642                       sty_val = XtMalloc(sizeof(char) * (strlen(moji) + 1));
 643                       strcpy(sty_val, moji);
 644                       sty_flag = True;
 645               }
 646               XtFree(moji);
 647         }
 648
 649         create_xlfd();
 650         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 651 }
 652
 653 static void
 654 wls_call(w)
 655 Widget w;
 656 {
 657         XmString label;
 658         char *moji;
 659
 660         XtVaGetValues(w, XmNlabelString, &label, NULL);
 661
 662         moji = (char *) _XmStringUngenerate((XmString) label, NULL,
 663                                         XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 664         if (moji) {
 665               if(strncmp(moji, "*", 1) == 0) {
 666                       wls_flag = False;
 667               }
 668               else {
 669                       wls_val = atoi(moji);
 670                       wls_flag = True;
 671               }
 672               XtFree(moji);
 673         }
 674
 675         XmStringFree(label);
 676         create_xlfd();
 677         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 678 }
 679
 680 static void
 681 hls_call(w)
 682 Widget w;
 683 {
 684         XmString label;
 685         char *moji;
 686         XtVaGetValues(w, XmNlabelString, &label, NULL);
 687
 688         moji = (char *) _XmStringUngenerate((XmString) label, NULL,
 689                                         XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 690         if (moji) {
 691               if(strncmp(moji, "*", 1) == 0) {
 692                       hls_flag = False;
 693               }
 694               else {
 695                       hls_val = atoi(moji);
 696                       hls_flag = True;
 697               }
 698               XtFree(moji);
 699         }
 700         XmStringFree(label);
 701         create_xlfd();
 702         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 703 }
 704
 705 static void
 706 button_set1()
 707 {
 708     int         i, j;
 709     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 710     FalFontData key;
 711     FalFontDataList *fontlist;
 712     FalFontData *f;
 713     Boolean found;
 714
 715     if (sty_flag == True) {
 716         key.style.name = sty_val;
 717         mask |= FAL_FONT_MASK_STYLE_NAME;
 718     }
 719     if (wls_flag == True) {
 720         key.size.w = wls_val;
 721         mask |= FAL_FONT_MASK_SIZE_W;
 722     }
 723     if (hls_flag == True) {
 724         key.size.h = hls_val;
 725         mask |= FAL_FONT_MASK_SIZE_H;
 726     }
 727     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 728         for (j=0; j<udc_count; j++)
 729             XtSetSensitive(button1[j], False);
 730         return;
 731     }
 732     if(fontlist->num == 0) {
 733         for (j=0; j<udc_count; j++)
 734             XtSetSensitive(button1[j], False);
 735         FalFreeFontList(fontlist);
 736         return;
 737     }
 738
 739     for (j=0; j<udc_count; j++) {
 740         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 741             if(udc[j] == f->cd_set) {
 742                 found = True;
 743                 break;
 744             }
 745         }
 746         if(found == False)
 747             XtSetSensitive(button1[j], False);
 748         else
 749             XtSetSensitive(button1[j], True);
 750     }
 751     FalFreeFontList(fontlist);
 752 }
 753
 754 static void
 755 button_set2()
 756 {
 757     int         i, j;
 758     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 759     FalFontData key;
 760     FalFontDataList *fontlist;
 761     FalFontData *f;
 762     Boolean found;
 763
 764     if (udc_flag == True) {
 765         key.cd_set = udc_val;
 766         mask |= FAL_FONT_MASK_CODE_SET;
 767     }
 768     if (wls_flag == True) {
 769         key.size.w = wls_val;
 770         mask |= FAL_FONT_MASK_SIZE_W;
 771     }
 772     if (hls_flag == True) {
 773         key.size.h = hls_val;
 774         mask |= FAL_FONT_MASK_SIZE_H;
 775     }
 776     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 777         for (j=0; j<sty_count; j++)
 778             XtSetSensitive(button2[j], False);
 779         return;
 780     }
 781     if(fontlist->num == 0) {
 782         for (j=0; j<sty_count; j++)
 783             XtSetSensitive(button2[j], False);
 784         FalFreeFontList(fontlist);
 785         return;
 786     }
 787
 788     for (j=0; j<sty_count; j++) {
 789         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 790             if(strcmp(sty[j], f->style.name) == 0) {
 791                 found = True;
 792                 break;
 793             }
 794         }
 795         if(found == False)
 796             XtSetSensitive(button2[j], False);
 797         else
 798             XtSetSensitive(button2[j], True);
 799     }
 800     FalFreeFontList(fontlist);
 801 }
 802
 803 static void
 804 button_set3()
 805 {
 806     int         i, j;
 807     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 808     FalFontData key;
 809     FalFontDataList *fontlist;
 810     FalFontData *f;
 811     Boolean found;
 812
 813     if (udc_flag == True) {
 814         key.cd_set = udc_val;
 815         mask |= FAL_FONT_MASK_CODE_SET;
 816     }
 817     if (sty_flag == True) {
 818         key.style.name = sty_val;
 819         mask |= FAL_FONT_MASK_STYLE_NAME;
 820     }
 821     if (hls_flag == True) {
 822         key.size.h = hls_val;
 823         mask |= FAL_FONT_MASK_SIZE_H;
 824     }
 825     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 826         for (j=0; j<wls_count; j++)
 827             XtSetSensitive(button3[j], False);
 828         return;
 829     }
 830     if(fontlist->num == 0) {
 831         for (j=0; j<wls_count; j++)
 832             XtSetSensitive(button3[j], False);
 833         FalFreeFontList(fontlist);
 834         return;
 835     }
 836
 837     for (j=0; j<wls_count; j++) {
 838         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 839             if(wls[j] == f->size.w) {
 840                 found = True;
 841                 break;
 842             }
 843         }
 844         if(found == False)
 845             XtSetSensitive(button3[j], False);
 846         else
 847             XtSetSensitive(button3[j], True);
 848     }
 849     FalFreeFontList(fontlist);
 850 }
 851
 852 static void
 853 button_set4()
 854 {
 855     int         i, j;
 856     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 857     FalFontData key;
 858     FalFontDataList *fontlist;
 859     FalFontData *f;
 860     Boolean found;
 861
 862     if (udc_flag == True) {
 863         key.cd_set = udc_val;
 864         mask |= FAL_FONT_MASK_CODE_SET;
 865     }
 866     if (sty_flag == True) {
 867         key.style.name = sty_val;
 868         mask |= FAL_FONT_MASK_STYLE_NAME;
 869     }
 870     if (wls_flag == True) {
 871         key.size.w = wls_val;
 872         mask |= FAL_FONT_MASK_SIZE_W;
 873     }
 874     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 875         for (j=0; j<hls_count; j++)
 876             XtSetSensitive(button4[j], False);
 877         return;
 878     }
 879     if(fontlist->num == 0) {
 880         for (j=0; j<hls_count; j++)
 881             XtSetSensitive(button4[j], False);
 882         FalFreeFontList(fontlist);
 883         return;
 884     }
 885
 886     for (j=0; j<hls_count; j++) {
 887         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 888             if(hls[j] == f->size.h) {
 889                 found = True;
 890                 break;
 891             }
 892         }
 893         if (found == False)
 894             XtSetSensitive(button4[j], False);
 895         else
 896             XtSetSensitive(button4[j], True);
 897     }
 898     FalFreeFontList(fontlist);
 899 }
 900
 901 void
 902 data_sort(data, count)
 903 int *data;
 904 int count;
 905 {
 906     int *p1, *p2, tmp, i;
 907
 908     for (; count; count--) {
 909         for (i=1, p1=data, p2=data+1; i < count; i++, p1++, p2++) {
 910             if( *p1 > *p2) {
 911                 tmp = *p2;
 912                 *p2 = *p1;
 913                 *p1 = tmp;
 914             }
 915         }
 916     }
 917 }
 918
 919
 920 static void
 921 font_init() /* dtex change */
 922 {
 923         FalFontDataList *fontlist;
 924         FalFontData     *f;
 925         Boolean         found;
 926         int             i, j;
 927         char            tmp[16];
 928         char            err[128];
 929         Widget          button;
 930         int             ans; /* dtex add */
 931 /*      extern void Error_message(); dtex del */
 932         char *p;
 933
 934         p = GETMESSAGE(4, 8, "There is no font");
 935         xlf_count = udc_count = sty_count = wls_count = hls_count = 0;
 936         if (FalGetFontList(NULL, FAL_FONT_MASK_DEFINED |
 937                         FAL_FONT_MASK_UNDEFINED, &fontlist) == FAL_ERROR) {
 938                 sprintf(err, "%s", ERROR_1);
 939 /*              Error_message((Widget)NULL, err); dtex del */
 940                 AskUser(ed->toplevel, ed, err, &ans, "error");
 941                 return;
 942         }
 943         if(fontlist->num == 0) {
 944                 FalFreeFontList(fontlist);
 945 /*              strcpy(err, resource.mn_no_font); dtex change */
 946                 strcpy(err, p);
 947 /*              Error_message((Widget)NULL, err); dtex del */
 948                 AskUser(ed->toplevel, ed, err, &ans, "error");
 949                 return;
 950         }
 951         udc = (int *)XtMalloc(sizeof(int) * fontlist->num);
 952         sty = (char **)XtMalloc(sizeof(char *) * fontlist->num);
 953         wls = (int *)XtMalloc(sizeof(int) * fontlist->num);
 954         hls = (int *)XtMalloc(sizeof(int) * fontlist->num);
 955         for (i=0, f=fontlist->list; i < fontlist->num; i++, f++) {
 956             for (j=0,found=False; j<udc_count; j++) {
 957                 if(udc[j] == f->cd_set) {
 958                         found=True;
 959                         break;
 960                 }
 961             }
 962             if (found == False) {
 963                 udc[udc_count++] = f->cd_set;
 964             }
 965             for (j=0,found=False; j<sty_count; j++) {
 966                 if(strcmp(sty[j], f->style.name) == 0) {
 967                         found=True;
 968                         break;
 969                 }
 970             }
 971             if (found == False) {
 972                 sty[sty_count] = XtMalloc(sizeof(char) * (strlen(f->style.name) + 1));
 973                 strcpy(sty[sty_count++], f->style.name);
 974             }
 975             if (f->size.w != -1) {
 976             for (j=0,found=False; j<wls_count; j++) {
 977                 if(wls[j] == f->size.w) {
 978                         found=True;
 979                         break;
 980                 }
 981             }
 982             if (found == False) {
 983                 wls[wls_count++] = f->size.w;
 984             }
 985             }
 986             for (j=0,found=False; j<hls_count; j++) {
 987                 if(hls[j] == f->size.h) {
 988                         found=True;
 989                         break;
 990                 }
 991             }
 992             if (found == False) {
 993                 hls[hls_count++] = f->size.h;
 994             }
 995         }
 996         FalFreeFontList(fontlist);
 997
 998         data_sort(udc, udc_count);
 999         data_sort(wls, wls_count);
1000         data_sort(hls, hls_count);
1001
1002         if (udc_count > 0) {
1003           button1 = (Widget *) XtMalloc(sizeof(Widget) * udc_count);
1004         }
1005         if (sty_count > 0) {
1006           button2 = (Widget *) XtMalloc(sizeof(Widget) * sty_count);
1007         }
1008         if (wls_count > 0) {
1009           button3 = (Widget *) XtMalloc(sizeof(Widget) * wls_count);
1010         }
1011         if (hls_count > 0) {
1012           button4 = (Widget *) XtMalloc(sizeof(Widget) * hls_count);
1013         }
1014
1015         button = XmCreatePushButton(pull1, "*", NULL, 0);
1016         XtManageChild(button);
1017         XtAddCallback(button, XmNactivateCallback,
1018                                                 (XtCallbackProc)udc_call, NULL);
1019         for (i=0; i < udc_count; i++) {
1020                 if(udc[i] == FAL_FONT_CS0)
1021                         sprintf(tmp, CS0);
1022                 else if(udc[i] == FAL_FONT_CS1)
1023                         sprintf(tmp, CS1);
1024                 else if(udc[i] == FAL_FONT_CS2)
1025                         sprintf(tmp, CS2);
1026                 else if(udc[i] == FAL_FONT_CS3)
1027                         sprintf(tmp, CS3);
1028                 else
1029                         sprintf(tmp, "Codeset %x?", udc[i]);
1030                 button1[i] = XmCreatePushButton(pull1, tmp, NULL, 0);
1031                 XtManageChild(button1[i]);
1032                 XtAddCallback(button1[i], XmNactivateCallback,
1033                                                 (XtCallbackProc)udc_call, NULL);
1034         }
1035
1036         button = XmCreatePushButton(pull2, "*", NULL, 0);
1037         XtManageChild(button);
1038         XtAddCallback(button, XmNactivateCallback,
1039                                                 (XtCallbackProc)sty_call, NULL);
1040         for (i=0; i < sty_count; i++) {
1041                 button2[i] = XmCreatePushButton(pull2, sty[i], NULL, 0);
1042                 XtManageChild(button2[i]);
1043                 XtAddCallback(button2[i], XmNactivateCallback,
1044                                                 (XtCallbackProc)sty_call, NULL);
1045         }
1046
1047         button = XmCreatePushButton(pull3, "*", NULL, 0);
1048         XtManageChild(button);
1049         XtAddCallback(button, XmNactivateCallback,
1050                                                 (XtCallbackProc)wls_call, NULL);
1051         for (i=0; i < wls_count; i++) {
1052                 sprintf(tmp, "%d", wls[i]);
1053                 button3[i] = XmCreatePushButton(pull3, tmp, NULL, 0);
1054                 XtManageChild(button3[i]);
1055                 XtAddCallback(button3[i], XmNactivateCallback,
1056                                                 (XtCallbackProc)wls_call, NULL);
1057         }
1058
1059         button = XmCreatePushButton(pull4, "*", NULL, 0);
1060         XtManageChild(button);
1061         XtAddCallback(button, XmNactivateCallback,
1062                                                 (XtCallbackProc)hls_call, NULL);
1063         for (i=0; i < hls_count; i++) {
1064                 sprintf(tmp, "%d", hls[i]);
1065                 button4[i] = XmCreatePushButton(pull4, tmp, NULL, 0);
1066                 XtManageChild(button4[i]);
1067                 XtAddCallback(button4[i], XmNactivateCallback,
1068                                                 (XtCallbackProc)hls_call, NULL);
1069         }
1070 }
1071
1072
1073 static Widget
1074 CreateSelectXLFD( top ) /* dtex change */
1075 Widget  top ;
1076 {
1077
1078         int             n;
1079         Arg             args[16];
1080         XmString        xms, xms1 ;
1081         Widget          editW ;
1082         Widget          frame, row1, label1, row2, cas1, cas2, cas3, cas4;
1083         XmString        str;
1084         char            *p;
1085         udc_flag = sty_flag = wls_flag = hls_flag = False;
1086
1087         /*
1088         *  create base window
1089         */
1090         n = 0 ;
1091         XtSetArg( args[n], XmNautoUnmanage, False ) ;           n++ ;
1092         XtSetArg( args[n], XmNtitle, maintitle ) ;n++ ; /* dtex add */
1093         XtSetArg( args[n], XmNnoResize, True ) ;                n++ ;
1094         XtSetArg( args[n], XmNminimizeButtons, True ) ;         n++ ;
1095 /*        xms = XmStringCreateLocalized( resource.exec_label ) ; dtex change*/
1096         p = GETMESSAGE(4, 10, "Open");
1097         xms = XmStringCreateLocalized( p ) ;
1098         XtSetArg( args[n], XmNokLabelString, xms ) ;            n++ ;
1099 /*        xms1 = XmStringCreateLocalized( resource.quit_label) ; dtex change*/
1100         p = GETMESSAGE(4, 12, "Cancel");
1101         xms1 = XmStringCreateLocalized( p ) ;
1102         XtSetArg( args[n], XmNhelpLabelString, xms1 ) ;         n++ ;
1103 /*        editW = XmCreateTemplateDialog( top, "dtfonteditor - Open", args, n ); dtex change*/
1104         p = GETMESSAGE(4, 14, "UDC data exchange utility");
1105         editW = XmCreateTemplateDialog( top, p, args, n );
1106
1107         XmStringFree( xms ) ;
1108         XmStringFree( xms1 ) ;
1109
1110         n = 0;
1111         pull1 = XmCreatePulldownMenu(toplevel, "pull", args, n);
1112         pull2 = XmCreatePulldownMenu(toplevel, "pull", args, n);
1113         pull3 = XmCreatePulldownMenu(toplevel, "pull", args, n);
1114         pull4 = XmCreatePulldownMenu(toplevel, "pull", args, n);
1115
1116         n = 0 ;
1117         xlfdWform  = XmCreateRowColumn( editW, "BaseForm", args, n );
1118         XtManageChild( xlfdWform );
1119
1120         n = 0;
1121         frame = XmCreateFrame( xlfdWform, "frame", args, n);
1122         XtManageChild( frame );
1123
1124         n = 0 ;
1125         row1  = XmCreateRowColumn( frame, "row", args, n );
1126         XtManageChild( row1 );
1127
1128         p = GETMESSAGE(4, 16, "SelectItems");
1129         n = 0;
1130         label1 = XmCreateLabel( row1, p, args, n);
1131         XtManageChild( label1 );
1132
1133         n = 0 ;
1134         row2  = XmCreateRowColumn( row1, "row", args, n );
1135         XtManageChild( row2 );
1136
1137         n = 0 ;
1138         /*str = XmStringCreateLocalized(resource.l_codeset) ; dtex change */
1139         p = GETMESSAGE(4, 18, "- Codeset:");
1140         str = XmStringCreateLocalized( p );
1141         XtSetArg(args[n], XmNlabelString, str);  n++;
1142         XtSetArg(args[n], XmNsubMenuId, pull1);  n++;
1143         cas1  = XmCreateOptionMenu( row2, "CodeSet", args, n );
1144         XtManageChild( cas1 );
1145         XtAddCallback(XmOptionButtonGadget(cas1), XmNcascadingCallback,
1146                                         (XtCallbackProc)button_set1, NULL);
1147         XmStringFree(str);
1148
1149         n = 0 ;
1150         /*str = XmStringCreateLocalized(resource.l_style) ; dtex change */
1151         p = GETMESSAGE(4, 20, "-   Style:");
1152         str = XmStringCreateLocalized( p );
1153         XtSetArg(args[n], XmNlabelString, str);  n++;
1154         XtSetArg(args[n], XmNsubMenuId, pull2);  n++;
1155         cas2  = XmCreateOptionMenu( row2, "Style", args, n );
1156         XtAddCallback(XmOptionButtonGadget(cas2), XmNcascadingCallback,
1157                                         (XtCallbackProc)button_set2, NULL);
1158         XtManageChild( cas2 );
1159         XmStringFree(str);
1160
1161         n = 0 ;
1162         /*str = XmStringCreateLocalized(resource.l_width) ; dtex change */
1163         p = GETMESSAGE(4, 22, "-   Width:");
1164         str = XmStringCreateLocalized( p );
1165         XtSetArg(args[n], XmNlabelString, str);  n++;
1166         XtSetArg(args[n], XmNsubMenuId, pull3);  n++;
1167         cas3  = XmCreateOptionMenu( row2, "Width", args, n );
1168         XtManageChild( cas3 );
1169         XtAddCallback(XmOptionButtonGadget(cas3), XmNcascadingCallback,
1170                                         (XtCallbackProc)button_set3, NULL);
1171         XmStringFree(str);
1172
1173         n = 0 ;
1174         /*str = XmStringCreateLocalized(resource.l_height) ; dtex change */
1175         p = GETMESSAGE(4, 24, "-  Height:");
1176         str = XmStringCreateLocalized( p );
1177         XtSetArg(args[n], XmNlabelString, str);  n++;
1178         XtSetArg(args[n], XmNsubMenuId, pull4);  n++;
1179         cas4  = XmCreateOptionMenu( row2, "Height", args, n );
1180         XtManageChild( cas4 );
1181         XtAddCallback(XmOptionButtonGadget(cas4), XmNcascadingCallback,
1182                                         (XtCallbackProc)button_set4, NULL);
1183         XmStringFree(str);
1184
1185         font_init();
1186         create_xlfd();
1187
1188         n = 0;
1189         XtSetArg(args[n], XmNvisibleItemCount, 10) ;    n++ ;
1190         XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT) ;      n++ ;
1191         XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC) ;        n++ ;
1192         XtSetArg(args[n], XmNselectionPolicy, XmSINGLE_SELECT) ;        n++ ;
1193         XtSetArg(args[n], XmNitems, xlf) ;      n++ ;
1194         XtSetArg(args[n], XmNitemCount, xlf_count) ;    n++ ;
1195         scrolllist = XmCreateScrolledList(xlfdWform, "scrolllist", args, n);
1196         XtManageChild(scrolllist);
1197
1198         /*
1199          * Error_Messege
1200          */
1201
1202         XtAddCallback(editW, XmNokCallback, (XtCallbackProc)OpenWindowCB, NULL);
1203 /*        XtAddCallback(editW, XmNokCallback, (XtCallbackProc)ReadCB, NULL); dtex del */
1204         XtAddCallback(editW, XmNcancelCallback, (XtCallbackProc)quit, NULL);
1205 /*        XtAddCallback(editW, XmNhelpCallback,
1206                                         (XtCallbackProc)OpenCancelCB, NULL); dtex del */
1207         XtAddCallback(editW, XmNhelpCallback,
1208                                         (XtCallbackProc)quit, NULL);
1209
1210         return( editW ) ;
1211 }
1212