cde/programs/dtudcfonted/cpyx.c

   1 /* cpyx.c 1.29 - Fujitsu source for CDEnext    96/10/30 13:13:45      */
   2 /* $XConsortium: cpyx.c /main/8 1996/11/08 01:52:55 cde-fuj $ */
   3 /*
   4  *  (c) Copyright 1995 FUJITSU LIMITED
   5  *  This is source code modified by FUJITSU LIMITED under the Joint
   6  *  Development Agreement for the CDEnext PST.
   7  *  This is unpublished proprietary source code of FUJITSU LIMITED
   8  */
   9
  10
  11 #include <string.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <nl_types.h>
  15
  16 #include<X11/Xlib.h>
  17 #include<X11/Xutil.h>
  18 #include<X11/Xatom.h>
  19
  20 #include <Xm/XmAll.h>
  21
  22 /*
  23  * There is no public header file for this function (only an
  24  * internal header XmStringI.h).
  25  */
  26 extern XtPointer _XmStringUngenerate (XmString string,
  27                         XmStringTag tag,
  28                         XmTextType tag_type,
  29                         XmTextType output_type);
  30
  31 #include "util.h"
  32 #include "selectxlfd.h"
  33 #include "xoakufont.h"
  34
  35 #include "xpm.h"
  36 #ifdef XPM
  37 #define ReadXpm XpmCreatePixmapFromData
  38 #else
  39 #define ReadXpm _DtXpmCreatePixmapFromData
  40 #endif
  41 #include "pixmaps/arrow.pm"
  42
  43 static Widget   CreateCopyXLFD() ;
  44 static void     CpyXLFDCB() ;
  45
  46 extern  int     CreateOtherLabelAndText();
  47 extern  Widget  xlfdCreateScrolledList();
  48 extern  int     GetItemsToDisplay();
  49
  50 extern  void    xlfdPopupDialog();
  51
  52 extern  void    InitCpyPtn() ;
  53 extern  void    _unmap();
  54 extern  void    CpyCB() ;
  55 extern  void    PopdownCpyPtn() ;
  56 extern  void    AddPopupProc() ;
  57
  58 extern FalFontData fullFontData;
  59
  60 /*
  61  * parameters
  62  */
  63
  64 FalFontData     copyFontData;
  65
  66 extern  Widget  toplevel ;
  67 Widget  cpyDialog=NULL;
  68 static Widget codeLabel[COPYLABELS];
  69 static Widget codeText[COPYLABELS+1];
  70
  71 extern  TextField SrcTf;
  72 extern  TextField DestTf;
  73
  74 extern  char AreaStr[160];
  75
  76 /*
  77  *  resource database
  78  */
  79 extern  Resource resource ;
  80
  81 #define CS0 "Codeset 0"
  82 #define CS1 "Codeset 1"
  83 #define CS2 "Codeset 2"
  84 #define CS3 "Codeset 3"
  85
  86 #define FAL_ERROR_STR resource.falerrmsg[((fal_utyerrno & 0xff) > 25) ? 0 : (fal_utyerrno & 0xff)]
  87
  88 static Widget           pull1, pull2, pull3, pull4, scrolllist;
  89 static int      xlf_count = 0;
  90 static XmString *xlf=NULL;
  91 static int      udc_count = 0;
  92 static Boolean  udc_flag = False;
  93 static int      *udc=NULL;
  94 static int      udc_val;
  95 static int      sty_count = 0;
  96 static Boolean  sty_flag = False;
  97 static char     **sty=NULL;
  98 static char     *sty_val=NULL;
  99 static int      wls_count = 0;
 100 static Boolean  wls_flag = False;
 101 static int      *wls=NULL;
 102 static int      wls_val;
 103 static int      hls_count = 0;
 104 static Boolean  hls_flag = False;
 105 static int      *hls=NULL;
 106 static int      hls_val;
 107 static Widget       *button1=NULL;
 108 static Widget       *button2=NULL;
 109 static Widget       *button3=NULL;
 110 static Widget       *button4=NULL;
 111 static Widget       focus_widget=NULL;
 112
 113 /****************************************************************
 114  * callbacks                                                    *
 115  ***************************************************************/
 116
 117
 118 /*ARGSUSED*/
 119 static void
 120 CpyXLFDCB(w, client_data, call_data)
 121 Widget  w;
 122 caddr_t client_data, *call_data;
 123 {
 124     char        *str;
 125     XmStringTable       st;
 126     /* get font file name (str:  XLFD name)     */
 127     /* get font file name (str:  XLFD name)     */
 128     XtVaGetValues(scrolllist, XmNselectedItems, &st, NULL);
 129     if( st == NULL ){
 130         copyFontData.xlfdname = NULL;
 131         return ;
 132     }
 133     str = _XmStringUngenerate(st[0], NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 134     copyFontData.xlfdname = str;
 135     if(udc_flag == True)
 136         copyFontData.cd_set = udc_val;
 137     else
 138         copyFontData.cd_set = -1;
 139 }
 140
 141
 142 void
 143 CpyPtnXLFD()
 144 {
 145     if( cpyDialog == NULL )
 146     {
 147         CreateCopyXLFD( toplevel ) ;
 148
 149         /*
 150          * add callbacks
 151          */
 152         XtAddCallback(cpyDialog, XmNokCallback, (XtCallbackProc)_unmap, NULL);
 153         XtAddCallback(cpyDialog, XmNokCallback,
 154                                         (XtCallbackProc)CpyXLFDCB, NULL);
 155         XtAddCallback(cpyDialog, XmNokCallback, (XtCallbackProc)CpyCB, NULL);
 156
 157         XtAddCallback(cpyDialog, XmNcancelCallback,
 158                                 (XtCallbackProc)_unmap, (XtPointer)1);
 159         XtAddCallback(cpyDialog, XmNcancelCallback,
 160                                 (XtCallbackProc)CpyXLFDCB,  (XtPointer)1);
 161         XtAddCallback(cpyDialog, XmNcancelCallback,
 162                                 (XtCallbackProc)CpyCB, (XtPointer)1);
 163         XtAddCallback(cpyDialog, XmNhelpCallback, (XtCallbackProc)_unmap, NULL);
 164         XtAddCallback(cpyDialog, XmNhelpCallback,
 165                                 (XtCallbackProc)PopdownCpyPtn, NULL);
 166
 167         AddPopupProc( cpyDialog, InitCpyPtn ) ;
 168
 169         SrcTf.w1  = codeText[0] ;
 170         SrcTf.w2  = codeText[1] ;
 171         DestTf.w1 = codeText[2] ;
 172         DestTf.w2 = NULL;
 173
 174     }
 175     xlfdPopupDialog( cpyDialog );
 176 }
 177
 178
 179 static void
 180 create_xlfd()
 181 {
 182         int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 183         FalFontData key;
 184         FalFontDataList *fontlist;
 185         FalFontData *f;
 186         int i;
 187
 188         if (udc_flag == True) {
 189                 key.cd_set = udc_val;
 190                 mask |= FAL_FONT_MASK_CODE_SET;
 191         }
 192         if (sty_flag == True) {
 193                 key.style.name = sty_val;
 194                 mask |= FAL_FONT_MASK_STYLE_NAME;
 195         }
 196         if (wls_flag == True) {
 197                 key.size.w = wls_val;
 198                 mask |= FAL_FONT_MASK_SIZE_W;
 199         }
 200         if (hls_flag == True) {
 201                 key.size.h = hls_val;
 202                 mask |= FAL_FONT_MASK_SIZE_H;
 203         }
 204         xlf_count = 0;
 205         if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 206                 return;
 207         }
 208         if(fontlist->num == 0) {
 209                 FalFreeFontList(fontlist);
 210                 return;
 211         }
 212         xlf = (XmString *)XtMalloc(sizeof(XmString) * fontlist->num);
 213         for (i=0, f=fontlist->list; i < fontlist->num; i++, f++) {
 214             xlf[xlf_count++] = XmStringCreateLocalized(f->xlfdname);
 215         }
 216         FalFreeFontList(fontlist);
 217 }
 218
 219 static void
 220 udc_call(w)
 221 Widget w;
 222 {
 223         XmString label;
 224         char *moji;
 225         XtVaGetValues(w, XmNlabelString, &label, NULL);
 226         moji = _XmStringUngenerate(label, NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 227         if(strncmp(moji, "*", 1) == 0) {
 228                 udc_flag = False;
 229         } else if(strcmp(moji, CS0) == 0) {
 230                 udc_val = FAL_FONT_CS0;
 231                 udc_flag = True;
 232         } else if(strcmp(moji, CS1) == 0) {
 233                 udc_val = FAL_FONT_CS1;
 234                 udc_flag = True;
 235         } else if(strcmp(moji, CS2) == 0) {
 236                 udc_val = FAL_FONT_CS2;
 237                 udc_flag = True;
 238         } else if(strcmp(moji, CS3) == 0) {
 239                 udc_val = FAL_FONT_CS3;
 240                 udc_flag = True;
 241         } else {
 242                 udc_flag = False;
 243         }
 244         XtFree(moji);
 245         create_xlfd();
 246         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 247 }
 248
 249 static void
 250 sty_call(w)
 251 Widget w;
 252 {
 253         XmString label;
 254         char *moji;
 255         if (sty_val) {
 256                 XtFree(sty_val);
 257                 sty_val = NULL;
 258         }
 259         XtVaGetValues(w, XmNlabelString, &label, NULL);
 260         moji = _XmStringUngenerate(label, NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 261         if(strncmp(moji, "*", 1) == 0) {
 262                 sty_flag = False;
 263         }
 264         else {
 265                 sty_val = XtMalloc(sizeof(char) * (strlen(moji) + 1));
 266                 strcpy(sty_val, moji);
 267                 sty_flag = True;
 268         }
 269         XtFree(moji);
 270         create_xlfd();
 271         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 272 }
 273
 274 static void
 275 wls_call(w)
 276 Widget w;
 277 {
 278         XmString label;
 279         char *moji;
 280         XtVaGetValues(w, XmNlabelString, &label, NULL);
 281         moji = _XmStringUngenerate(label, NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 282         if(strncmp(moji, "*", 1) == 0) {
 283                 wls_flag = False;
 284         }
 285         else {
 286                 wls_val = atoi(moji);
 287                 wls_flag = True;
 288         }
 289         XmStringFree(label);
 290         XtFree(moji);
 291         create_xlfd();
 292         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 293 }
 294
 295 static void
 296 hls_call(w)
 297 Widget w;
 298 {
 299         XmString label;
 300         char *moji;
 301         XtVaGetValues(w, XmNlabelString, &label, NULL);
 302         moji = _XmStringUngenerate(label, NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 303         if(strncmp(moji, "*", 1) == 0) {
 304                 hls_flag = False;
 305         }
 306         else {
 307                 hls_val = atoi(moji);
 308                 hls_flag = True;
 309         }
 310         XmStringFree(label);
 311         XtFree(moji);
 312         create_xlfd();
 313         XtVaSetValues(scrolllist, XmNitems, xlf, XmNitemCount, xlf_count, NULL);
 314 }
 315
 316 static void
 317 button_set1()
 318 {
 319     int         i, j;
 320     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 321     FalFontData key;
 322     FalFontDataList *fontlist;
 323     FalFontData *f;
 324     Boolean found;
 325
 326     if (sty_flag == True) {
 327         key.style.name = sty_val;
 328         mask |= FAL_FONT_MASK_STYLE_NAME;
 329     }
 330     if (wls_flag == True) {
 331         key.size.w = wls_val;
 332         mask |= FAL_FONT_MASK_SIZE_W;
 333     }
 334     if (hls_flag == True) {
 335         key.size.h = hls_val;
 336         mask |= FAL_FONT_MASK_SIZE_H;
 337     }
 338     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 339         for (j=0; j<udc_count; j++)
 340             XtSetSensitive(button1[j], False);
 341         return;
 342     }
 343     if(fontlist->num == 0) {
 344         FalFreeFontList(fontlist);
 345         for (j=0; j<udc_count; j++)
 346             XtSetSensitive(button1[j], False);
 347         return;
 348     }
 349
 350     for (j=0; j<udc_count; j++) {
 351         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 352             if(udc[j] == f->cd_set) {
 353                 found = True;
 354                 break;
 355             }
 356         }
 357         if(found == False)
 358             XtSetSensitive(button1[j], False);
 359         else
 360             XtSetSensitive(button1[j], True);
 361     }
 362     FalFreeFontList(fontlist);
 363 }
 364
 365 static void
 366 button_set2()
 367 {
 368     int         i, j;
 369     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 370     FalFontData key;
 371     FalFontDataList *fontlist;
 372     FalFontData *f;
 373     Boolean found;
 374
 375     if (udc_flag == True) {
 376         key.cd_set = udc_val;
 377         mask |= FAL_FONT_MASK_CODE_SET;
 378     }
 379     if (wls_flag == True) {
 380         key.size.w = wls_val;
 381         mask |= FAL_FONT_MASK_SIZE_W;
 382     }
 383     if (hls_flag == True) {
 384         key.size.h = hls_val;
 385         mask |= FAL_FONT_MASK_SIZE_H;
 386     }
 387     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 388         for (j=0; j<sty_count; j++)
 389             XtSetSensitive(button2[j], False);
 390         return;
 391     }
 392     if(fontlist->num == 0) {
 393         for (j=0; j<sty_count; j++)
 394             XtSetSensitive(button2[j], False);
 395         FalFreeFontList(fontlist);
 396         return;
 397     }
 398
 399     for (j=0; j<sty_count; j++) {
 400         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 401             if(strcmp(sty[j], f->style.name) == 0) {
 402                 found = True;
 403                 break;
 404             }
 405         }
 406         if(found == False)
 407             XtSetSensitive(button2[j], False);
 408         else
 409             XtSetSensitive(button2[j], True);
 410     }
 411     FalFreeFontList(fontlist);
 412 }
 413
 414 static void
 415 button_set3()
 416 {
 417     int         i, j;
 418     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 419     FalFontData key;
 420     FalFontDataList *fontlist;
 421     FalFontData *f;
 422     Boolean found;
 423
 424     if (udc_flag == True) {
 425         key.cd_set = udc_val;
 426         mask |= FAL_FONT_MASK_CODE_SET;
 427     }
 428     if (sty_flag == True) {
 429         key.style.name = sty_val;
 430         mask |= FAL_FONT_MASK_STYLE_NAME;
 431     }
 432     if (hls_flag == True) {
 433         key.size.h = hls_val;
 434         mask |= FAL_FONT_MASK_SIZE_H;
 435     }
 436     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 437        for (j=0; j<wls_count; j++)
 438             XtSetSensitive(button3[j], False);
 439         return;
 440     }
 441     if(fontlist->num == 0) {
 442        for (j=0; j<wls_count; j++)
 443             XtSetSensitive(button3[j], False);
 444         FalFreeFontList(fontlist);
 445         return;
 446     }
 447
 448     for (j=0; j<wls_count; j++) {
 449         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 450             if(wls[j] == f->size.w) {
 451                 found = True;
 452                 break;
 453             }
 454         }
 455         if(found == False)
 456             XtSetSensitive(button3[j], False);
 457         else
 458             XtSetSensitive(button3[j], True);
 459     }
 460     FalFreeFontList(fontlist);
 461 }
 462
 463 static void
 464 button_set4()
 465 {
 466     int         i, j;
 467     int mask = FAL_FONT_MASK_DEFINED | FAL_FONT_MASK_UNDEFINED;
 468     FalFontData key;
 469     FalFontDataList *fontlist;
 470     FalFontData *f;
 471     Boolean found;
 472
 473     if (udc_flag == True) {
 474         key.cd_set = udc_val;
 475         mask |= FAL_FONT_MASK_CODE_SET;
 476     }
 477     if (sty_flag == True) {
 478         key.style.name = sty_val;
 479         mask |= FAL_FONT_MASK_STYLE_NAME;
 480     }
 481     if (wls_flag == True) {
 482         key.size.w = wls_val;
 483         mask |= FAL_FONT_MASK_SIZE_W;
 484     }
 485     if (FalGetFontList(&key, mask, &fontlist) == FAL_ERROR) {
 486         for (j=0; j<hls_count; j++)
 487             XtSetSensitive(button4[j], False);
 488         return;
 489     }
 490     if(fontlist->num == 0) {
 491         for (j=0; j<hls_count; j++)
 492             XtSetSensitive(button4[j], False);
 493         FalFreeFontList(fontlist);
 494         return;
 495     }
 496
 497     for (j=0; j<hls_count; j++) {
 498         for (i=0, f=fontlist->list, found=False; i < fontlist->num; i++, f++) {
 499             if(hls[j] == f->size.h) {
 500                 found = True;
 501                 break;
 502             }
 503         }
 504         if (found == False)
 505             XtSetSensitive(button4[j], False);
 506         else
 507             XtSetSensitive(button4[j], True);
 508     }
 509     FalFreeFontList(fontlist);
 510 }
 511
 512
 513 static void
 514 font_init()
 515 {
 516         FalFontDataList *fontlist;
 517         FalFontData     *f;
 518         Boolean         found;
 519         int             i, j;
 520         char            tmp[16];
 521         char            err[128];
 522         Widget          button;
 523         extern void     data_sort();
 524         extern void     Error_message();
 525
 526         xlf_count = udc_count = sty_count = wls_count = hls_count = 0;
 527         if (FalGetFontList(NULL, FAL_FONT_MASK_DEFINED |
 528                         FAL_FONT_MASK_UNDEFINED, &fontlist) == FAL_ERROR) {
 529                 strcpy(err, FAL_ERROR_STR);
 530                 Error_message((Widget)NULL, err);
 531                 return;
 532         }
 533         if(fontlist->num == 0) {
 534                 FalFreeFontList(fontlist);
 535                 strcpy(err, resource.mn_no_font);
 536                 Error_message((Widget)NULL, err);
 537                 return;
 538         }
 539         xlf = (XmString *)XtMalloc(sizeof(XmString) * fontlist->num);
 540         udc = (int *)XtMalloc(sizeof(int) * fontlist->num);
 541         sty = (char **)XtMalloc(sizeof(char *) * fontlist->num);
 542         wls = (int *)XtMalloc(sizeof(int) * fontlist->num);
 543         hls = (int *)XtMalloc(sizeof(int) * fontlist->num);
 544         for (i=0, f=fontlist->list; i < fontlist->num; i++, f++) {
 545             xlf[xlf_count++] = XmStringCreateLocalized(f->xlfdname);
 546             for (j=0,found=False; j<udc_count; j++) {
 547                 if(udc[j] == f->cd_set) {
 548                         found=True;
 549                         break;
 550                 }
 551             }
 552             if (found == False) {
 553                 udc[udc_count++] = f->cd_set;
 554             }
 555             for (j=0,found=False; j<sty_count; j++) {
 556                 if(strcmp(sty[j], f->style.name) == 0) {
 557                         found=True;
 558                         break;
 559                 }
 560             }
 561             if (found == False) {
 562                 sty[sty_count] = XtMalloc(sizeof(char) * (strlen(f->style.name) + 1));
 563                 strcpy(sty[sty_count++], f->style.name);
 564             }
 565             if (f->size.w != -1) {
 566             for (j=0,found=False; j<wls_count; j++) {
 567                 if(wls[j] == f->size.w) {
 568                         found=True;
 569                         break;
 570                 }
 571             }
 572             if (found == False) {
 573                 wls[wls_count++] = f->size.w;
 574             }
 575             }
 576             for (j=0,found=False; j<hls_count; j++) {
 577                 if(hls[j] == f->size.h) {
 578                         found=True;
 579                         break;
 580                 }
 581             }
 582             if (found == False) {
 583                 hls[hls_count++] = f->size.h;
 584             }
 585         }
 586         FalFreeFontList(fontlist);
 587
 588         data_sort(udc, udc_count);
 589         data_sort(wls, wls_count);
 590         data_sort(hls, hls_count);
 591
 592         button1 = (Widget *) XtMalloc(sizeof(Widget) * udc_count);
 593         button2 = (Widget *) XtMalloc(sizeof(Widget) * sty_count);
 594         button3 = (Widget *) XtMalloc(sizeof(Widget) * wls_count);
 595         button4 = (Widget *) XtMalloc(sizeof(Widget) * hls_count);
 596
 597         button = XmCreatePushButton(pull1, "*", NULL, 0);
 598         XtManageChild(button);
 599         XtAddCallback(button, XmNactivateCallback,
 600                                                 (XtCallbackProc)udc_call, NULL);
 601         for (i=0; i < udc_count; i++) {
 602                 if(udc[i] == FAL_FONT_CS0)
 603                         sprintf(tmp, CS0);
 604                 else if(udc[i] == FAL_FONT_CS1)
 605                         sprintf(tmp, CS1);
 606                 else if(udc[i] == FAL_FONT_CS2)
 607                         sprintf(tmp, CS2);
 608                 else if(udc[i] == FAL_FONT_CS3)
 609                         sprintf(tmp, CS3);
 610                 else
 611                         sprintf(tmp, "Codeset %x?", udc[i]);
 612                 button1[i] = XmCreatePushButton(pull1, tmp, NULL, 0);
 613                 XtManageChild(button1[i]);
 614                 XtAddCallback(button1[i], XmNactivateCallback,
 615                                                 (XtCallbackProc)udc_call, NULL);
 616         }
 617
 618         button = XmCreatePushButton(pull2, "*", NULL, 0);
 619         XtManageChild(button);
 620         XtAddCallback(button, XmNactivateCallback,
 621                                                 (XtCallbackProc)sty_call, NULL);
 622         for (i=0; i < sty_count; i++) {
 623                 button2[i] = XmCreatePushButton(pull2, sty[i], NULL, 0);
 624                 XtManageChild(button2[i]);
 625                 XtAddCallback(button2[i], XmNactivateCallback,
 626                                                 (XtCallbackProc)sty_call, NULL);
 627         }
 628
 629         button = XmCreatePushButton(pull3, "*", NULL, 0);
 630         XtManageChild(button);
 631         XtAddCallback(button, XmNactivateCallback,
 632                                                 (XtCallbackProc)wls_call, NULL);
 633         for (i=0; i < wls_count; i++) {
 634                 sprintf(tmp, "%d", wls[i]);
 635                 button3[i] = XmCreatePushButton(pull3, tmp, NULL, 0);
 636                 XtManageChild(button3[i]);
 637                 XtAddCallback(button3[i], XmNactivateCallback,
 638                                                 (XtCallbackProc)wls_call, NULL);
 639         }
 640
 641         button = XmCreatePushButton(pull4, "*", NULL, 0);
 642         XtManageChild(button);
 643         XtAddCallback(button, XmNactivateCallback,
 644                                                 (XtCallbackProc)hls_call, NULL);
 645         for (i=0; i < hls_count; i++) {
 646                 sprintf(tmp, "%d", hls[i]);
 647                 button4[i] = XmCreatePushButton(pull4, tmp, NULL, 0);
 648                 XtManageChild(button4[i]);
 649                 XtAddCallback(button4[i], XmNactivateCallback,
 650                                                 (XtCallbackProc)hls_call, NULL);
 651         }
 652 }
 653
 654 /*ARGSUSED*/
 655 static void
 656 arrow_change(w, wid)
 657 Widget w;
 658 Widget wid;
 659 {
 660     if (XtIsSensitive(wid)) {
 661         XtSetSensitive(wid, False);
 662     } else {
 663         XtSetSensitive(wid, True);
 664     }
 665 }
 666
 667 static void
 668 focus(w)
 669 Widget w;
 670 {
 671     focus_widget = w;
 672 }
 673
 674 static void
 675 code_input()
 676 {
 677     char        *str;
 678     XmStringTable       st;
 679     extern void CodeWindow();
 680     XtVaGetValues(scrolllist, XmNselectedItems, &st, NULL);
 681     if( st == NULL ){
 682         return ;
 683     }
 684     str = _XmStringUngenerate(st[0], NULL, XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
 685     CodeWindow(focus_widget, str, True);
 686 }
 687
 688 static void
 689 code_input2()
 690 {
 691     extern void CodeWindow();
 692     CodeWindow(codeText[2], fullFontData.xlfdname, False);
 693 }
 694
 695 static Widget
 696 CreateCopyXLFD( top )
 697 Widget  top ;
 698 {
 699
 700         int             n;
 701         Arg             args[16];
 702         XmString        xms, xms1, xms2 ;
 703         Widget          frame, row, label1, row1, row2, row3, row4, row5;
 704         Widget          sep, cas1, cas2, cas3, cas4;
 705         Widget          arrow, code;
 706         XmString        str;
 707         extern Pixmap   arrow_pix;
 708         Display             *disp;
 709         Window              root;
 710         Pixmap              mask;
 711         XpmAttributes       attr;
 712
 713         udc_flag = sty_flag = wls_flag = hls_flag = False;
 714
 715         /*
 716         *  create base window
 717         */
 718         n = 0 ;
 719         XtSetArg( args[n], XmNautoUnmanage,     False ) ;        n++ ;
 720         xms = XmStringCreateLocalized( resource.l_copy ) ;
 721         XtSetArg( args[n], XmNokLabelString,    xms ) ;         n++ ;
 722         xms1 = XmStringCreateLocalized( resource.l_overlay ) ;
 723         XtSetArg( args[n], XmNcancelLabelString, xms1 ) ;       n++ ;
 724         xms2 = XmStringCreateLocalized( resource.quit_label) ;
 725         XtSetArg( args[n], XmNhelpLabelString,  xms2 ) ;        n++ ;
 726         XtSetArg( args[n], XmNnoResize,         True ) ;        n++ ;
 727         XtSetArg( args[n], XmNminimizeButtons,  True ) ;        n++ ;
 728         XtSetArg( args[n], XmNtitle,    resource.l_copy_title) ;        n++ ;
 729         cpyDialog = XmCreateTemplateDialog( top, "copy_dialog", args, n );
 730
 731         XmStringFree( xms ) ;
 732         XmStringFree( xms1 ) ;
 733         XmStringFree( xms2 ) ;
 734
 735         n = 0;
 736         pull1 = XmCreatePulldownMenu(top, "pull", args, n);
 737         pull2 = XmCreatePulldownMenu(top, "pull", args, n);
 738         pull3 = XmCreatePulldownMenu(top, "pull", args, n);
 739         pull4 = XmCreatePulldownMenu(top, "pull", args, n);
 740
 741         n = 0 ;
 742         row  = XmCreateRowColumn( cpyDialog, "BaseForm", args, n );
 743         XtManageChild( row );
 744
 745         n = 0;
 746         frame = XmCreateFrame( row, "frame", args, n);
 747         XtManageChild( frame );
 748
 749         n = 0 ;
 750         row1  = XmCreateRowColumn( frame, "row", args, n );
 751         XtManageChild( row1 );
 752
 753         n = 0;
 754         str = XmStringCreateLocalized(resource.l_selectitem) ;
 755         XtSetArg(args[n], XmNlabelString, str);  n++;
 756         label1 = XmCreateLabel( row1, "SelectItems", args, n);
 757         XtManageChild( label1 );
 758         XmStringFree(str);
 759
 760         n = 0 ;
 761         row2  = XmCreateRowColumn( row1, "row", args, n );
 762         XtManageChild( row2 );
 763
 764         n = 0 ;
 765         str = XmStringCreateLocalized(resource.l_codeset) ;
 766         XtSetArg(args[n], XmNlabelString, str);  n++;
 767         XtSetArg(args[n], XmNsubMenuId, pull1);  n++;
 768         cas1  = XmCreateOptionMenu( row2, "CodeSet", args, n );
 769         XtManageChild( cas1 );
 770         XtAddCallback(XmOptionButtonGadget(cas1), XmNcascadingCallback,
 771                                         (XtCallbackProc)button_set1, NULL);
 772         XmStringFree(str);
 773
 774         n = 0 ;
 775         str = XmStringCreateLocalized(resource.l_style) ;
 776         XtSetArg(args[n], XmNlabelString, str);  n++;
 777         XtSetArg(args[n], XmNsubMenuId, pull2);  n++;
 778         cas2  = XmCreateOptionMenu( row2, "Style", args, n );
 779         XtAddCallback(XmOptionButtonGadget(cas2), XmNcascadingCallback,
 780                                         (XtCallbackProc)button_set2, NULL);
 781         XtManageChild( cas2 );
 782         XmStringFree(str);
 783
 784         n = 0 ;
 785         str = XmStringCreateLocalized(resource.l_width) ;
 786         XtSetArg(args[n], XmNlabelString, str);  n++;
 787         XtSetArg(args[n], XmNsubMenuId, pull3);  n++;
 788         cas3  = XmCreateOptionMenu( row2, "Width", args, n );
 789         XtManageChild( cas3 );
 790         XtAddCallback(XmOptionButtonGadget(cas3), XmNcascadingCallback,
 791                                         (XtCallbackProc)button_set3, NULL);
 792         XmStringFree(str);
 793
 794         n = 0 ;
 795         str = XmStringCreateLocalized(resource.l_height) ;
 796         XtSetArg(args[n], XmNlabelString, str);  n++;
 797         XtSetArg(args[n], XmNsubMenuId, pull4);  n++;
 798         cas4  = XmCreateOptionMenu( row2, "Height", args, n );
 799         XtManageChild( cas4 );
 800         XtAddCallback(XmOptionButtonGadget(cas4), XmNcascadingCallback,
 801                                         (XtCallbackProc)button_set4, NULL);
 802         XmStringFree(str);
 803
 804         font_init();
 805
 806         n = 0;
 807         XtSetArg(args[n], XmNvisibleItemCount, 10) ;    n++ ;
 808         XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT) ;      n++ ;
 809         XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC) ;        n++ ;
 810         XtSetArg(args[n], XmNselectionPolicy, XmSINGLE_SELECT) ;        n++ ;
 811         XtSetArg(args[n], XmNitems, xlf) ;      n++ ;
 812         XtSetArg(args[n], XmNitemCount, xlf_count) ;    n++ ;
 813         scrolllist = XmCreateScrolledList(row, "scrolllist", args, n);
 814         XtManageChild(scrolllist);
 815
 816         n = 0;
 817         sep = XmCreateSeparator(row, "sep", args, n);
 818         XtManageChild(sep);
 819
 820         n = 0 ;
 821         row3  = XmCreateRowColumn( row, "row", args, n );
 822         XtManageChild( row3 );
 823
 824         if (! arrow_pix) {
 825             disp = XtDisplay(row);
 826             root = DefaultRootWindow(disp);
 827             attr.valuemask = 0;
 828             ReadXpm(disp, root, arrow_pm, &arrow_pix, &mask, &attr);
 829         }
 830
 831         n = 0 ;
 832         XtSetArg(args[n], XmNorientation, XmHORIZONTAL) ;       n++ ;
 833         row4  = XmCreateRowColumn( row3, "row", args, n );
 834         XtManageChild( row4 );
 835
 836         xms = XmStringCreateLocalized(resource.l_copy_src_code);
 837         n = 0;
 838         XtSetArg(args[n], XmNlabelString, xms); n++ ;
 839         codeLabel[0] = XmCreateLabel(row4 , "copylabel", args, n);
 840         XtManageChild(codeLabel[0]);
 841         XmStringFree( xms ) ;
 842
 843         n = 0;
 844         XtSetArg(args[n], XmNcolumns,   4);                     n++;
 845         XtSetArg(args[n], XmNmaxLength, 4);                     n++;
 846         XtSetArg(args[n], XmNeditable,  True);                  n++;
 847         XtSetArg(args[n], XmNcursorPositionVisible, True);      n++;
 848         focus_widget = codeText[0] = XmCreateText(row4 , "copytext",
 849                                                                 args, n);
 850         XtManageChild(codeText[0]);
 851
 852         XtAddCallback(codeText[0], XmNfocusCallback, (XtCallbackProc)focus, NULL);
 853
 854         n = 0;
 855         XtSetArg(args[n], XmNlabelPixmap, arrow_pix);  n++;
 856         XtSetArg(args[n], XmNlabelType, XmPIXMAP); n++;
 857         XtSetArg(args[n], XmNindicatorOn, False); n++;
 858         XtSetArg(args[n], XmNshadowThickness, 2); n++;
 859         XtSetArg(args[n], XmNfillOnSelect, False); n++;
 860         XtSetArg(args[n], XmNhighlightThickness, 0); n++;
 861         arrow = XmCreateToggleButton(row4, "arrow", args, n);
 862         XtManageChild(arrow);
 863
 864         n = 0;
 865         XtSetArg(args[n], XmNcolumns,   4);                     n++;
 866         XtSetArg(args[n], XmNmaxLength, 4);                     n++;
 867         XtSetArg(args[n], XmNeditable,  True);                  n++;
 868         XtSetArg(args[n], XmNcursorPositionVisible, True);      n++;
 869         codeText[1] = XmCreateText(row4 , "copytext", args, n);
 870         XtManageChild(codeText[1]);
 871         XtSetSensitive(codeText[1], False);
 872
 873         XtAddCallback(codeText[1], XmNfocusCallback, (XtCallbackProc)focus, NULL);
 874
 875         XtAddCallback(arrow, XmNvalueChangedCallback,
 876                         (XtCallbackProc)arrow_change, (XtPointer)codeText[1]);
 877
 878         n = 0;
 879         xms = XmStringCreateLocalized(resource.code) ;
 880         XtSetArg(args[n], XmNlabelString, xms); n++;
 881         XtSetArg(args[n], XmNhighlightThickness, 0); n++;
 882         code = XmCreatePushButton(row4, "Code", args, n);
 883         XtManageChild(code);
 884         XmStringFree(xms);
 885
 886         XtAddCallback(code, XmNactivateCallback,
 887                         (XtCallbackProc)code_input, (XtPointer)NULL);
 888
 889         n = 0 ;
 890         XtSetArg(args[n], XmNorientation, XmHORIZONTAL) ;       n++ ;
 891         row5  = XmCreateRowColumn( row3, "row", args, n );
 892         XtManageChild( row5 );
 893
 894         xms = XmStringCreateLocalized(resource.l_copy_dest_code);
 895
 896         n = 0;
 897         XtSetArg(args[n], XmNlabelString, xms); n++ ;
 898         codeLabel[1] = XmCreateLabel(row5 , "copylabel", args, n);
 899         XtManageChild(codeLabel[1]);
 900         XmStringFree( xms ) ;
 901
 902         n = 0;
 903         XtSetArg(args[n], XmNcolumns,   4);                     n++;
 904         XtSetArg(args[n], XmNmaxLength, 4);                     n++;
 905         XtSetArg(args[n], XmNeditable,  True);                  n++;
 906         XtSetArg(args[n], XmNcursorPositionVisible, True);      n++;
 907         codeText[2] = XmCreateText(row5 , "copytext", args, n);
 908         XtManageChild(codeText[2]);
 909
 910         n = 0;
 911         xms = XmStringCreateLocalized(resource.code) ;
 912         XtSetArg(args[n], XmNlabelString, xms); n++;
 913         XtSetArg(args[n], XmNhighlightThickness, 0); n++;
 914         code = XmCreatePushButton(row5, "Code", args, n);
 915         XtManageChild(code);
 916         XmStringFree(xms);
 917
 918         XtAddCallback(code, XmNactivateCallback,
 919                         (XtCallbackProc)code_input2, (XtPointer)NULL);
 920
 921         return( cpyDialog ) ;
 922 }