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