cde/programs/dtudcexch/selectxlfd.c

   1 /* $XConsortium: selectxlfd.c /main/3 1996/10/14 14:45:17 barstow $ */
   2 /*
   3  *  All Rights Reserved, Copyright (c) FUJITSU LIMITED 1995
   4  */
   5
   6
   7 #include <string.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <math.h>
  11 #include <nl_types.h>
  12 #include <sys/types.h>
  13 #include <sys/stat.h>
  14 #include <fcntl.h>
  15
  16 #include<X11/Xlib.h>
  17 #include<X11/Xutil.h>
  18 #include<X11/Xatom.h>
  19
  20 #include <Xm/Xm.h>
  21 #include <Xm/Form.h>
  22 #include <Xm/PushB.h>
  23 #include <Xm/Text.h>
  24 #include <Xm/TextF.h>
  25 #include <Xm/Label.h>
  26 #include <Xm/SeparatoG.h>
  27 #include <Xm/List.h>
  28 #include <Xm/ToggleB.h>
  29 #include <Xm/MessageB.h>
  30
  31 #include "FaLib.h"
  32 #include "falxlfd.h"
  33 #include "selectxlfd.h"
  34 #include "excutil.h"
  35
  36 char *shell_n[] = { "pop0", "pop1", "pop2", "pop3" } ;
  37 char *list_n[]  = { "list0", "list1", "list2", "list3" } ;
  38
  39 #ifdef DEBUG
  40 #undef Dprintf
  41 #define Dprintf fprintf
  42 #else
  43 #define Dprintf
  44 #endif /* DEBUG */
  45
  46 /*
  47  * There is no public header file for this function (only an
  48  * internal header XmStringI.h).
  49  */
  50 extern XtPointer _XmStringUngenerate (XmString string,
  51                         XmStringTag tag,
  52                         XmTextType tag_type,
  53                         XmTextType output_type);
  54
  55 extern Rsrc resource;
  56 extern Exc_data *ed;
  57 extern ListData *ld;
  58 extern fal_utyerror;
  59 extern fal_utyderror;
  60 extern fal_utyexists;
  61 extern char *maintitle;
  62
  63 FalFontID       fid;
  64
  65
  66 /*
  67  * parameters
  68  */
  69
  70 char    *fullPathName   = NULL ;
  71
  72 FalFontDataList         *font_L ;
  73 FalxCodeList            *CodeList ;
  74 FalxStyleList           *StyleList ;
  75 FalxSizeList            *SizeList ;
  76 FalxUdcArea             *UdcArea ;
  77 int                     SelectedOffset ;
  78 int                     UdcAreaCount ;
  79 int                     getmask ;
  80
  81 FalxFontDataBuff        KeyBuff ;
  82
  83
  84 void    PopupSelectXLFD() ;
  85
  86 Widget  xlfdDialog, xlfdWform,
  87         slctBLabel[BUTTONITEMS],slctBText[BUTTONITEMS], slctButton[BUTTONITEMS],
  88         listPop[BUTTONITEMS],   listW[BUTTONITEMS],
  89         separatorW, errorMD, msgBox ;
  90 extern  Widget  cpyDialog ;
  91
  92 extern Widget toplevel;
  93
  94
  95 /*
  96  * tmp
  97  */
  98
  99 int fontcheck(char *fontfile, char *mode)
 100 /*
 101  * If fontfile can't be opend, return -1.
 102  * If fontfile is editted by other UDC client, return 1.
 103  * normary return 0.
 104  */
 105 {
 106     int chk_fd;
 107
 108     if (strcmp(mode, "r") == 0) {
 109         if ((chk_fd = open(fontfile, O_RDONLY)) < 0) {
 110             return (-1);
 111         }
 112     } else if (strcmp(mode, "w") == 0) {
 113         if ((chk_fd = open(fontfile, O_RDWR)) < 0) {
 114             return (-1);
 115         }
 116     }
 117     if (isLock(chk_fd) == 1) {
 118         close(chk_fd);
 119         return(1);
 120     }
 121     close(chk_fd);
 122     return (0);
 123 }
 124
 125 void setallcode(ListData *ld)
 126 {
 127     int         i, code, codenum;
 128     int         *codep;
 129     int         code1, code2;
 130
 131     codenum = 0;
 132     for (i = 0; i < UdcAreaCount; i++) {
 133         codenum += (abs(UdcArea[i].udc_end - UdcArea[i].udc_start) + 1);
 134     }
 135
 136     ld->allcode = (int *) calloc(codenum, sizeof(int));
 137     ld->allcode_num = codenum;
 138     codep = ld->allcode;
 139     for (i = 0; i < UdcAreaCount; i++) {
 140         code1 = smaller(UdcArea[i].udc_start, UdcArea[i].udc_end);
 141         code2 = bigger(UdcArea[i].udc_start, UdcArea[i].udc_end);
 142         for (code = code1; code <= code2; code++) {
 143             *codep = code;
 144             codep++;
 145         }
 146     }
 147 }
 148
 149 FalFontID openfont()
 150 {
 151     int         protect_key = FAL_FONT_DISPLAY;
 152     int         codeset;
 153     FalFontID   fontid;
 154
 155     fontid = NULL;
 156     codeset = font_L->list[0].cd_set;
 157     if ((fontid = FalOpenFont(fullPathName, protect_key, codeset))
 158         == FAL_ERROR) {
 159         fprintf(stderr, "FalOpenFont error\n");
 160         return ((FalFontID) NULL);
 161     }
 162     return (fontid);
 163 }
 164
 165 void makelist(ListData *ld)
 166 {
 167     char        *pattern;
 168     int         code;
 169     int         *existcodep, *allcodep;
 170     int         existcode_num;
 171     int         i;
 172 /*    FalFontinfo fontinfo;*/
 173
 174 /*    FalQueryFont(fid, &fontinfo);*/
 175
 176     ld->existcode = (int *) calloc(ld->allcode_num, sizeof(int));
 177     existcodep = ld->existcode ;
 178     allcodep = ld->allcode;
 179     existcode_num = 0;
 180     for (i = 0; i < ld->allcode_num; i++) {
 181         code = *allcodep;
 182         pattern = FalReadFont(fid, code, NULL, NULL);
 183         if (fal_utyexists == 0) {
 184             *existcodep = *allcodep;
 185             existcodep++;
 186             existcode_num++;
 187         }
 188         allcodep++;
 189     }
 190     ld->existcode_num = existcode_num;
 191 }
 192
 193 void setexistcode(ListData *ld)
 194 {
 195     int *codep, *allcodep;
 196     int i;
 197
 198 /* open font */
 199     fid = openfont();
 200
 201     makelist(ld);
 202
 203 /* close font */
 204     if (fid != NULL)
 205         FalCloseFont(fid);
 206 }
 207
 208
 209 char i2c(int num)
 210 {
 211     char c;
 212
 213     if ((0 <= num) && (num <= 9))
 214         c = '0' + num;
 215     else if ((10 <= num) && (num <= 15))
 216         c = 'a' + (num - 10);
 217     else
 218         fprintf(stderr,"error in i2c\n");
 219     return c;
 220 }
 221
 222 char *i2s(int code)
 223 {
 224     char        buf[8];
 225     char        *number;
 226     char        *cp;
 227     int         i;
 228     int         tmp;
 229     int         len;
 230
 231     tmp = code;
 232     for (i = 0; ; i++) {
 233         if (tmp < 16) {
 234             buf[i] = i2c(tmp);
 235             buf[i+1] = NULL;
 236             break;
 237         }
 238         buf[i] = i2c(tmp % 16);
 239         tmp = tmp / 16;
 240     }
 241     len = strlen(buf);
 242     number = (char *) calloc(len+3, sizeof(char));
 243     cp = number;
 244     memcpy(cp, "0x", 2);
 245     cp += 2;
 246     for (i = len - 1; i >= 0; i--) {
 247         *cp = buf[i];
 248         cp++;
 249     }
 250     *cp = NULL;
 251     return (number);
 252 }
 253
 254 void setexistcode_c(ListData *ld)
 255 {
 256     int         i;
 257     char        **code_cp;
 258     int         *codep;
 259
 260     if (ld->existcode_num == 0) {
 261         return;
 262     }
 263
 264     ld->existcode_c = (char **) calloc(ld->existcode_num, sizeof(char *));
 265     code_cp = ld->existcode_c;
 266     codep = ld->existcode;
 267     for (i = 0; i < ld->existcode_num; i++) {
 268         *code_cp = i2s(*codep);
 269         code_cp++;
 270         codep++;
 271     }
 272 }
 273
 274 void getexistcode(ListData *ld)
 275 {
 276     setallcode(ld);
 277     setexistcode(ld);
 278     setexistcode_c(ld);
 279 }
 280
 281
 282
 283 /****************************************************************
 284  * common functions                                             *
 285  ***************************************************************/
 286
 287 /*
 288  * pop up and down dialog box
 289  */
 290
 291 void
 292 xlfdPopupDialog(w)
 293 Widget w;
 294 {
 295     if (! XtIsManaged(w))
 296         XtManageChild(w);
 297     else
 298         XRaiseWindow(XtDisplayOfObject(w), XtWindow(XtParent(w)));
 299 }
 300
 301 void
 302 xlfdPopdownDialog(w)
 303 Widget w;
 304 {
 305     if (XtIsManaged(w)){
 306         XtUnmanageChild(w);
 307     }
 308 }
 309
 310
 311 /*
 312 * get pixel width
 313 */
 314 Dimension
 315 GetPixelWidth( w, columns, width )
 316 Widget          w ;
 317 int             columns ;
 318 Dimension       *width ;
 319 {
 320         Arg             args[1] ;
 321         XtSetArg( args[0], XmNwidth, width ) ;
 322         XtGetValues( w , args, 1 ) ;
 323         return( *width / (Dimension)columns ) ;
 324 }
 325
 326
 327 /****************************************************************
 328  * callbacks                                                    *
 329  ***************************************************************/
 330
 331 void quit(w, client_data, call_data)
 332 Widget  w;
 333 caddr_t *client_data, *call_data;
 334 {
 335     char        *msg;
 336     int         ans;
 337
 338     msg = GETMESSAGE(6, 2, "Do you want to terminate udcexchange?");
 339
 340     AskUser(ed->toplevel, ed, msg, &ans, "question");
 341     if (ans == 1) {/* terminate ok */
 342         FalxFreeCodeList( CodeList ) ;
 343         FalxFreeStyleList( StyleList ) ;
 344         FalxFreeSizeList( SizeList ) ;
 345         FalxFreeFontList( font_L ) ;
 346         excterminate(ed);
 347     }
 348 }
 349
 350
 351 /*
 352  * Unmanage widgets
 353  */
 354 int
 355 ClearText( num, slctBText )
 356 int     num ;
 357 Widget  *slctBText ;
 358 {
 359         int     i ;
 360         /* toggle button unset */
 361         for( i=0; i<BUTTONITEMS; i++ ){
 362             if( i>num ){
 363                 XmTextSetString( slctBText[i], "" );
 364             }
 365         }
 366         return ;
 367 }
 368
 369 int
 370 ClearButtons( num, slctButton )
 371 int     num ;
 372 Widget  *slctButton ;
 373 {
 374         int     i, cnt ;
 375         Boolean isSet ;
 376         Arg     args[5] ;
 377         /* toggle button unset */
 378         for( i=0; i<BUTTONITEMS; i++ ){
 379             if( i != num ){
 380                 cnt = 0;
 381                 XtSetArg( args[cnt], XmNset, &isSet );  cnt++;
 382                 XtGetValues( slctButton[i], args, cnt );
 383                 if( isSet == True ){
 384                     cnt = 0;
 385                     XtSetArg( args[cnt], XmNset, False );       cnt++;
 386                     XtSetValues( slctButton[i], args, cnt );
 387                 }
 388             }
 389         }
 390         return ;
 391 }
 392
 393
 394
 395 /*
 396  * get text field position
 397  */
 398 int
 399 GetPositionOfLists( num, xlfdDialog, listPop, slctBText, x, y )
 400 int     num ;
 401 Widget  xlfdDialog ;
 402 Widget  *listPop ;
 403 Widget  *slctBText ;
 404 Position        *x ;
 405 Position        *y ;
 406 {
 407         int             i ;
 408         Position        tbx, tby, tx, ty ;
 409         Dimension       theight ;
 410         Arg     args[10] ;
 411
 412         i = 0;
 413         XtSetArg(args[i], XmNx, &tbx ); i++;
 414         XtSetArg(args[i], XmNy, &tby ); i++;
 415         XtGetValues( xlfdDialog, args, i);
 416         i = 0;
 417         XtSetArg(args[i], XmNx, &tx );  i++;
 418         XtSetArg(args[i], XmNy, &ty );  i++;
 419         XtSetArg(args[i], XmNheight, &theight );        i++;
 420         if( num==BUTTONITEMS-1 )
 421             XtGetValues( slctBText[num], args, i ) ;
 422         else
 423             XtGetValues( XtParent(slctBText[num]), args, i ) ;  /* ScrolledText */
 424         /*  determine the position of list */
 425         *x = tx + tbx + CX ;
 426         if( num==BUTTONITEMS-1 ){
 427         *y = ty + tby + (Position)theight + 14 + CY ;
 428         }else{
 429         *y = ty + tby + (Position)theight + CY ;
 430         }
 431
 432         for( i=0; i<BUTTONITEMS; i++ ){
 433             if( XtIsManaged( listPop[i] ) )     XtUnmanageChild( listPop[i] );
 434         }
 435         if( !XtIsManaged( listPop[num] ) )      XtManageChild( listPop[num] );
 436
 437         return ;
 438 }
 439
 440
 441
 442
 443 void listEH(w, num, event)
 444 Widget  w ;
 445 int     num ;
 446 XButtonEvent    *event;
 447 {
 448         int             i, j, ITEM_COUNT;
 449         Arg             args[10];
 450         XmString        *xms ;
 451         char            *str ;
 452
 453         int             rtn ;
 454         Position        x, y ;
 455
 456         /*
 457          *      get list items
 458          */
 459         ITEM_COUNT = 0;
 460         rtn = GetItemsToDisplay( num, &ITEM_COUNT, &xms ) ;
 461         switch( rtn ){
 462             case FALX_TRY_NEXT :
 463                 fprintf( stderr, "There are no fonts that was required.\n" ) ;
 464                 XmTextSetString( slctBText[0], " " );
 465                 ClearText( -1, slctBText ) ;
 466                 FalxFreeDataBuff( FALX_ALL, &KeyBuff ) ;
 467                 getmask = 0 ;
 468                 return ;
 469             case 0 :
 470                 break ;
 471             default :
 472                 fprintf( stderr, "GetItemsToDisplay() error.\n" ) ;
 473                 exit(-1) ;
 474         }
 475
 476         if( num == 0 && ITEM_COUNT == 1 ){
 477
 478             str = (char *) _XmStringUngenerate((XmString) xms[0], NULL,
 479                                         XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 480             if (str)
 481                XmTextSetString(slctBText[num], str );
 482             return ;
 483         }
 484         if( ITEM_COUNT < 0 ){
 485             exit(-1) ;
 486         }
 487
 488
 489         /*
 490          * get text field position
 491          */
 492         GetPositionOfLists( num, xlfdDialog, listPop, slctBText, &x, &y ) ;
 493
 494         i = 0;
 495         XtSetArg(args[i], XmNx, x  ) ;  i++;
 496         XtSetArg(args[i], XmNy, y  ) ;  i++;
 497         XtSetValues(listPop[num], args, i );
 498
 499         /*
 500          *      set list items
 501          */
 502         i = 0;
 503         XtSetArg (args[i], XmNitems, xms ); i++;
 504         XtSetArg (args[i], XmNitemCount, ITEM_COUNT ); i++;
 505         XtSetValues(listW[num], args, i );
 506
 507         /*
 508          * pop up list
 509          */
 510         XtPopup( listPop[num], XtGrabNone );
 511
 512 }
 513
 514
 515
 516
 517 void listPrintCB(w, num, call_data)
 518 Widget                  w;
 519 int                     num ;
 520 XmListCallbackStruct    *call_data;
 521 {
 522         char    *str ;
 523
 524         /* clear text fields and unset buttons */
 525         ClearButtons( num, slctButton ) ;
 526
 527
 528         str = (char *) _XmStringUngenerate((XmString) call_data->item, NULL,
 529                                         XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 530         if (str) {
 531             XmTextSetString(slctBText[num], str);
 532         }
 533
 534 #if 0
 535         /* set key data         */
 536         if( SetKeyBuff( num, str ) ){
 537             exit(-1) ;
 538         }
 539 #endif  /* 0 */
 540
 541         if( XtIsManaged( listPop[num] ) )       XtUnmanageChild( listPop[num] );
 542
 543 }
 544
 545
 546
 547
 548
 549 void OpenWindow(w, client_data, call_data)
 550 Widget  w;
 551 caddr_t client_data, *call_data;
 552 {
 553     int         r ;
 554     int         i ;
 555     int         ans;
 556     char        *msg;
 557     char        *msg1;
 558     char        *msg2;
 559     char        *msg3;
 560     char        *str, buff[512] ;
 561
 562     msg = GETMESSAGE(6, 4, "No UDCs exist in this font");
 563     msg1 = GETMESSAGE(6, 6, "XLFD name isn't selected");
 564     msg2 = GETMESSAGE(6, 8, "Can't open the font file");
 565     msg3 = GETMESSAGE(6, 10, "The font file is used by other UDC client.");
 566
 567     /* get font file name (str:  XLFD name)     */
 568     str = XmTextGetString( slctBText[0] );
 569     if (( str == NULL ) || (strcmp(str, "") == 0)) {
 570         AskUser(w, ed, msg1, &ans, "error");
 571         return;
 572     }
 573     if( fullPathName != NULL ){
 574         free( fullPathName ) ;
 575     }
 576     SelectedOffset = FalxSearchFontFileName( str, font_L, buff ) ;
 577     if( SelectedOffset < 0 ){
 578         exit(-1) ;
 579     }
 580     if( (fullPathName = strdup( buff )) == NULL ){
 581         exit(-1) ;
 582     }
 583     UdcAreaCount = FalxGetGlyphIndexInfo( str, font_L, &UdcArea ) ;
 584     if( UdcAreaCount < 0 ){
 585         exit(-1) ;
 586     }
 587
 588     if( fullPathName != NULL ){
 589         Dprintf( stderr, "OpenWindow() : full path name = %s\n", fullPathName );
 590     }
 591     for( i=0; i<UdcAreaCount; i++ ){
 592         Dprintf( stderr, "OpenWindow() : start(%d) = 0x%x\n", i, UdcArea[i].udc_start );
 593         Dprintf( stderr, "OpenWindow() : end  (%d) = 0x%x\n", i, UdcArea[i].udc_end );
 594     }
 595     if ((ed->xlfdname = strdup(str)) == NULL) {
 596         exit (-1);
 597     }
 598     if ((ed->fontfile = strdup(fullPathName)) == NULL) {
 599         exit (-1);
 600     }
 601 /*    getxlfd(ed);*/
 602 /* initialize ld */
 603     if ((ld = (ListData *) malloc(sizeof(ListData))) == NULL) {
 604         excerror(ed, EXCERRMALLOC, "selcharcd", "exit");
 605     }
 606     memset(ld, 0x00, sizeof(ListData));
 607     ld->ed = ed;
 608
 609     if (ed->function == EXPORT) {
 610         r = fontcheck(ed->fontfile, "r");
 611         if (r == -1) { /* file open error */
 612             AskUser(ld->ed->toplevel, ld->ed, msg2, &ans, "error");
 613             return;
 614         } else if (r == 1) { /* file is being editted by other UDC client */
 615             AskUser(ld->ed->toplevel, ld->ed, msg3, &ans, "error");
 616             return;
 617         }
 618         /* get existing UDC code */
 619         getexistcode(ld);
 620         if (ld->existcode_num == 0) {
 621             AskUser(ld->ed->toplevel, ld->ed, msg, &ans, "error");
 622             return;
 623         }
 624         XtUnmanageChild(xlfdDialog);
 625         selcharcd(ed);
 626     } else if (ed->function == IMPORT) {
 627         r = fontcheck(ed->fontfile, "w");
 628         if (r == -1) { /* file open error */
 629             AskUser(ld->ed->toplevel, ld->ed, msg2, &ans, "error");
 630             return;
 631         } else if (r == 1) { /* file is being editted by other UDC client */
 632             AskUser(ld->ed->toplevel, ld->ed, msg3, &ans, "error");
 633             return;
 634         }
 635         /* get existing UDC code */
 636         getexistcode(ld);
 637
 638         XtUnmanageChild(xlfdDialog);
 639         getcharcd(ed);
 640     }
 641 }
 642
 643
 644
 645 /****************************************************************
 646  * functions for create window view
 647 ****************************************************************/
 648
 649 #define SetLabel( cnt ){ \
 650         switch( cnt ){ \
 651             case 0 : buf = resource.xlfd_label ; break ; \
 652             case 1 : buf = resource.code_label ; break ; \
 653             case 2 : buf = resource.style_label; break ; \
 654             case 3 : buf = resource.size_label ; break ; \
 655         } \
 656         xms = XmStringCreateLocalized( buf ); \
 657 }
 658
 659
 660 int
 661 CreateXLFDLabelAndText( owner, slctBLabel, slctBText, slctButton )
 662 Widget  owner ;
 663 Widget  *slctBLabel ;
 664 Widget  *slctBText ;
 665 Widget  *slctButton ;
 666 {
 667
 668         Widget  _slctBLabel ;
 669         Widget  _slctBText ;
 670         Widget  _slctButton ;
 671         int             i, j;
 672         Arg             args[16];
 673         char            *buf ;
 674         XmString        xms ;
 675
 676         /*
 677         *  create XLFD titles
 678         */
 679         i = 0;
 680         XtSetArg( args[i], XmNx,            20 ) ;      i++ ;
 681         XtSetArg( args[i], XmNheight,       20 ) ;      i++ ;
 682         XtSetArg( args[i], XmNtopAttachment, XmATTACH_FORM ) ; i++ ;
 683         XtSetArg( args[i], XmNtopOffset,    20 ) ;      i++ ;
 684 /*
 685         _slctBLabel = XmCreateLabelGadget( owner , "xlfdlabel", args, i );
 686 */
 687         _slctBLabel = XmCreateLabel( owner , "xlfdlabel", args, i );
 688
 689         XtManageChild( _slctBLabel );
 690
 691         /*
 692         *  create text fields to display XLFD font name
 693         */
 694         i = 0;
 695         XtSetArg( args[i], XmNleftAttachment,   XmATTACH_FORM ) ; i++ ;
 696         XtSetArg( args[i], XmNleftOffset,       20 ) ;          i++ ;
 697         XtSetArg( args[i], XmNtopAttachment,    XmATTACH_WIDGET ); i++ ;
 698         XtSetArg( args[i], XmNtopOffset,        5 ) ;           i++ ;
 699         XtSetArg (args[i], XmNtopWidget,        _slctBLabel );  i++;
 700         XtSetArg( args[i], XmNcolumns,          XLFD_COLUMNS ) ;        i++ ;
 701         XtSetArg( args[i], XmNspacing,          0 ) ;           i++ ;
 702         XtSetArg( args[i], XmNeditMode, XmSINGLE_LINE_EDIT ) ;  i++ ;
 703         XtSetArg( args[i], XmNscrollBarDisplayPolicy,   XmAS_NEEDED ) ; i++ ;
 704         XtSetArg( args[i], XmNscrollingPolicy,   XmAPPLICATION_DEFINED ) ;  i++ ;
 705 /*
 706         XtSetArg( args[i], XmNscrollingPolicy,   XmAUTOMATIC ) ;  i++ ;
 707         XtSetArg( args[i], XmNlistSizePolicy,   XmCONSTANT ) ;  i++ ;
 708
 709         XtSetArg( args[i], XmNwidth, 600 ) ;                    i++ ;
 710         XtSetArg( args[i], XmNfontList, fixed ) ;       i++ ;
 711         XtSetArg( args[i], XmNeditable, True ) ;       i++ ;
 712         XtSetArg( args[i], XmNlistSizePolicy,   XmVARIABLE ) ;  i++ ;
 713 */
 714         _slctBText = XmCreateScrolledText( owner , "xlfdtext", args, i );
 715
 716         XtManageChild( _slctBText );
 717
 718         /*
 719         *  create XLFD select buttons
 720         */
 721         i = 0;
 722         XtSetArg( args[i], XmNindicatorType,    XmONE_OF_MANY ) ;       i++ ;
 723         XtSetArg (args[i], XmNtopWidget,        _slctBText );           i++;
 724         XtSetArg( args[i], XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET ) ;    i++ ;
 725         XtSetArg( args[i], XmNtopOffset,        15  ) ;                 i++ ;
 726         XtSetArg( args[i], XmNleftAttachment,   XmATTACH_WIDGET ) ;     i++ ;
 727         XtSetArg( args[i], XmNleftWidget,       _slctBText ) ;          i++ ;
 728         XtSetArg( args[i], XmNleftOffset,       5 ) ;           i++ ;   /* WIDTH */
 729         XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM ) ;      i++ ;
 730         XtSetArg( args[i], XmNrightOffset,      5 ) ;           i++ ;   /* WIDTH */
 731         xms = XmStringCreateLocalized( "" );
 732         XtSetArg( args[i], XmNlabelString,     xms ) ;      i++ ;
 733 /*
 734         _slctButton = XmCreateToggleButtonGadget( owner , "xlfdbtn", args, i);
 735 */
 736         _slctButton = XmCreateToggleButton( owner , "xlfdbtn", args, i);
 737
 738         XtManageChild( _slctButton );
 739
 740         *slctBLabel = _slctBLabel ;
 741         *slctBText  = _slctBText ;
 742         *slctButton = _slctButton ;
 743
 744 }
 745
 746
 747
 748
 749 int
 750 CreateOtherLabelAndText( num, owner, baseForm,
 751                          slctBLabel, topW, slctBText, slctButton )
 752 int     num ;
 753 Widget  owner ;
 754 Widget  baseForm ;
 755 Widget  *slctBLabel ;
 756 Widget  topW ;
 757 Widget  *slctBText ;
 758 Widget  *slctButton ;
 759 {
 760
 761         Widget  _slctBLabel ;
 762         Widget  _slctBText ;
 763         Widget  _slctButton ;
 764         int             i, j;
 765         Arg             args[16];
 766         char            *buf ;
 767         XmString        xms ;
 768
 769
 770         if( num < 1 )   return(0) ;
 771
 772         /*
 773         *  create key titles
 774         */
 775         i = 0;
 776         XtSetArg ( args[i], XmNtopWidget,
 777                 (num==1) ? baseForm : topW ); i++;
 778         XtSetArg( args[i], XmNx,            20 ) ;      i++ ;
 779         XtSetArg( args[i], XmNheight,       20 ) ;      i++ ;
 780         XtSetArg( args[i], XmNtopAttachment, XmATTACH_WIDGET ) ; i++ ;
 781 /* DEBUG
 782         XtSetArg( args[i], XmNtopOffset,    20 ) ;      i++ ;
 783 */
 784         XtSetArg( args[i], XmNtopOffset,    36 ) ;      i++ ;
 785         SetLabel(num) ;
 786         XtSetArg( args[i], XmNlabelString,      xms ) ; i++ ;
 787 /*
 788         _slctBLabel = XmCreateLabelGadget( owner , "label", args, i);
 789 */
 790         _slctBLabel = XmCreateLabel( owner , "label", args, i);
 791
 792         XtManageChild( _slctBLabel );
 793
 794         /*
 795         *  create text fields to display selected keys
 796         */
 797         i = 0;
 798         XtSetArg( args[i], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET ) ;       i++ ;
 799         XtSetArg( args[i], XmNtopOffset,        -5 ) ;          i++ ;
 800         XtSetArg (args[i], XmNtopWidget,        _slctBLabel );  i++;
 801         XtSetArg( args[i], XmNrightAttachment,  XmATTACH_OPPOSITE_WIDGET ) ; i++ ;
 802         XtSetArg( args[i], XmNrightOffset,      0 ) ;           i++ ;
 803         XtSetArg (args[i], XmNrightWidget,      baseForm );     i++;
 804         XtSetArg( args[i], XmNcolumns,          KEY_COLUMNS ) ;         i++ ;
 805         XtSetArg( args[i], XmNspacing,          0 ) ;           i++ ;
 806         XtSetArg( args[i], XmNeditMode,         XmSINGLE_LINE_EDIT ) ;  i++ ;
 807         XtSetArg( args[i], XmNscrollBarDisplayPolicy,   XmAS_NEEDED ) ; i++ ;
 808         XtSetArg( args[i], XmNscrollingPolicy,   XmAPPLICATION_DEFINED ) ;  i++ ;
 809         /*
 810         XtSetArg( args[i], XmNscrollingPolicy,   XmAUTOMATIC ) ;        i++ ;
 811         XtSetArg( args[i], XmNlistSizePolicy,   XmCONSTANT ) ;  i++ ;
 812
 813         XtSetArg( args[i], XmNfontList, fixed ) ;               i++ ;
 814         XtSetArg( args[i], XmNlistSizePolicy,   XmVARIABLE ) ;  i++ ;
 815         */
 816         if( num==BUTTONITEMS-1 )
 817             _slctBText = XmCreateText( owner , "text" , args, i );
 818         else
 819             _slctBText = XmCreateScrolledText( owner , "text" , args, i );
 820
 821         XtManageChild( _slctBText );
 822
 823         /*
 824         *  create select buttons
 825         */
 826         i = 0;
 827         XtSetArg( args[i], XmNindicatorType,    XmONE_OF_MANY ) ; i++ ;
 828         XtSetArg( args[i], XmNtopAttachment,    XmATTACH_OPPOSITE_WIDGET ) ;    i++ ;
 829         XtSetArg( args[i], XmNtopOffset,        5  ) ;          i++ ;
 830         XtSetArg (args[i], XmNtopWidget,        _slctBLabel );  i++;
 831         XtSetArg( args[i], XmNleftAttachment,   XmATTACH_WIDGET ) ;     i++ ;
 832         XtSetArg( args[i], XmNleftWidget,       _slctBText  ) ;         i++ ;
 833         XtSetArg( args[i], XmNleftOffset,       5 ) ;           i++ ;   /* WIDTH */
 834         xms = XmStringCreateLocalized( "" );
 835         XtSetArg( args[i], XmNlabelString,     xms ) ;          i++ ;
 836 /*
 837         _slctButton = XmCreateToggleButtonGadget( owner , "button", args, i);
 838 */
 839         _slctButton = XmCreateToggleButton( owner , "button", args, i);
 840
 841         XtManageChild( _slctButton );
 842
 843         *slctBLabel = _slctBLabel ;
 844         *slctBText  = _slctBText ;
 845         *slctButton = _slctButton ;
 846 }
 847
 848
 849
 850 /*
 851 * create pop up lists
 852 */
 853
 854
 855 Widget
 856 xlfdCreateScrolledList ( owner, name, args, n )
 857 Widget  owner ;
 858 char    *name ;
 859 Arg     *args ;
 860 int     n ;
 861 {
 862         Widget          listW ;
 863
 864         XtSetArg( args[n], XmNselectionPolicy,          XmSINGLE_SELECT ) ;n++ ;
 865         XtSetArg( args[n], XmNlistSpacing,              4 ) ;           n++ ;
 866         XtSetArg( args[n], XmNlistSizePolicy,           XmCONSTANT ) ;  n++ ;
 867         XtSetArg( args[n], XmNscrollBarDisplayPolicy,   XmAS_NEEDED ) ; n++ ;
 868         listW = XmCreateScrolledList( owner, name, args, n );
 869
 870         XtManageChild( listW );
 871
 872
 873         return( listW );
 874 }
 875
 876
 877
 878 /*
 879 * create selection window view
 880 */
 881 void
 882 PopupSelectXLFD( top )
 883 Widget  top ;
 884 {
 885
 886     int         n, i, j;
 887     Arg         args[16];
 888     char                *buf ;
 889     XmString    xms ;
 890     Dimension   pix, xwidth, kwidth ;
 891
 892     if( xlfdDialog == NULL ){
 893         /*
 894         *  create base window
 895         */
 896         n = 0 ;
 897         XtSetArg( args[n], XmNautoUnmanage, False ) ;           n++ ;
 898         XtSetArg( args[n], XmNtitle, maintitle ) ;              n++ ;
 899         XtSetArg( args[n], XmNnoResize, True ) ;                n++ ;
 900         xms = XmStringCreateLocalized( resource.exec_label ) ;
 901         XtSetArg( args[n], XmNokLabelString, xms ) ;            n++ ;
 902         xms = XmStringCreateLocalized( resource.quit_label) ;
 903         XtSetArg( args[n], XmNhelpLabelString, xms ) ;          n++ ;
 904 Dprintf( stdout, "(PopupSelectXLFD)XmCreateTemplateDialog: start\n" ) ;
 905         xlfdDialog = XmCreateTemplateDialog( top, "SelectDialog", args, n );
 906 Dprintf( stdout, "(PopupSelectXLFD)XmCreateTemplateDialog: end\n" ) ;
 907
 908         n = 0 ;
 909         xlfdWform  = XmCreateForm( xlfdDialog, "BaseForm", args, n );
 910         XtManageChild( xlfdWform );
 911
 912
 913         /*
 914         *  create XLFD columns
 915         */
 916 Dprintf( stdout, "(PopupSelectXLFD)CreateXLFDLabelAndText : start\n" ) ;
 917         CreateXLFDLabelAndText( xlfdWform ,
 918                                  &slctBLabel[0], &slctBText[0], &slctButton[0] ) ;
 919         n = 0 ;
 920         SetLabel(0) ;
 921         XtSetArg( args[n], XmNlabelString,      xms ) ; n++ ;
 922         XtSetValues( slctBLabel[0], args, n ) ;
 923 Dprintf( stdout, "(PopupSelectXLFD)CreateXLFDLabelAndText : end\n" ) ;
 924
 925         /*
 926         *  create other key columns
 927         */
 928 Dprintf( stdout, "(PopupSelectXLFD)CreateOtherLabelAndText :start\n" ) ;
 929         for( j=1; j<BUTTONITEMS; j++ ){
 930             CreateOtherLabelAndText( j, xlfdWform, slctBText[0],
 931                  &slctBLabel[j], slctBLabel[j-1], &slctBText[j], &slctButton[j] ) ;
 932         }
 933 Dprintf( stdout, "(PopupSelectXLFD)CreateOtherLabelAndText : end\n" ) ;
 934
 935         /* set bottom offsets */
 936         n = 0 ;
 937         XtSetArg( args[n], XmNbottomAttachment, XmATTACH_FORM ) ; n++ ;
 938         XtSetArg( args[n], XmNbottomOffset,     36 ) ;          n++ ;
 939         XtSetValues( slctBLabel[BUTTONITEMS-1], args, n ) ;
 940
 941         /* get pixel size */
 942         pix = GetPixelWidth( slctBText[0], XLFD_COLUMNS, &xwidth ) ;
 943         /* xwidth += pix / 2 ; */
 944         kwidth = pix * KEY_COLUMNS + pix / 2 ;
 945
 946         /*
 947         *  create popup shells
 948         */
 949         for( j=0; j<BUTTONITEMS; j++ ) {
 950             n = 0;
 951             listPop[j] = XtCreatePopupShell( shell_n[j], overrideShellWidgetClass,
 952                                              xlfdWform , args, n );
 953         }
 954
 955         /*
 956         *  create popup lists
 957         */
 958         for( j=0; j<BUTTONITEMS; j++ ) {
 959             n = 0 ;
 960             XtSetArg( args[n], XmNvisibleItemCount, (j==0)? 10 : 5 ) ;  n++ ;
 961             if( j==0 ){
 962                 XtSetArg( args[n], XmNwidth,   xwidth ) ;               n++ ;
 963             }else{
 964                 XtSetArg( args[n], XmNwidth,   kwidth ) ;               n++ ;
 965                 XtSetArg( args[n], XmNlistMarginWidth,   0 ) ;          n++ ;
 966             }
 967             listW[j] = xlfdCreateScrolledList( listPop[j], list_n[j], args, n );
 968         }
 969
 970         /*
 971          * Error_Messege
 972          */
 973 #if 0
 974         n = 0 ;
 975         XtSetArg( args[n], XmNokLabelString,    "OK" ) ;    n++ ;
 976         XtSetArg( args[n], XmNcancelLabelString,"Cancel" ) ;    n++ ;
 977         errorMD = XmCreateMessageDialog(toplevel, "ed0", NULL, 0);
 978
 979         msgBox = XmMessageBoxGetChild(errorMD, XmDIALOG_HELP_BUTTON);
 980         XtUnmanageChild(msgBox);
 981 #endif  /* 0 */
 982
 983         /*
 984          * add callbacks
 985          */
 986         for( i=0; i<BUTTONITEMS; i++ )
 987             XtAddEventHandler( slctButton[i], ButtonReleaseMask, False, (XtEventHandler) listEH, (XtPointer) i );
 988
 989         for( i=0; i<BUTTONITEMS; i++ )
 990             XtAddCallback(listW[i], XmNsingleSelectionCallback, (XtCallbackProc) listPrintCB, (XtPointer) i );
 991
 992         XtAddCallback( xlfdDialog, XmNokCallback, (XtCallbackProc) OpenWindow, NULL );
 993         XtAddCallback( xlfdDialog, XmNhelpCallback,(XtCallbackProc) quit,NULL );
 994
 995 #if 0
 996         XtAddCallback( errorMD, XmNcancelCallback, (XtCallbackProc) quit, NULL);
 997 #endif  /* 0 */
 998
 999     }
1000     /*
1001      * pop up select window
1002      */
1003 Dprintf( stdout, "(PopupSelectXLFD)xlfdPopupDialog : start\n" ) ;
1004     xlfdPopupDialog( xlfdDialog );
1005 Dprintf( stdout, "(PopupSelectXLFD)xlfdPopupDialog : end\n" ) ;
1006 Dprintf( stdout, " : end\n" ) ;
1007
1008 }
1009
1010
1011
1012 #undef SetLabel