util/fontsel.c

   1 static const char CVSID[] = "$Id: fontsel.c,v 1.28 2004/08/01 10:06:12 yooden Exp $";
   2 /*******************************************************************************
   3 *                                                                              *
   4 * fontsel.c -- Nirvana Font Selector                                           *
   5 *                                                                              *
   6 * Copyright (C) 1999 Mark Edel                                                 *
   7 *                                                                              *
   8 * This is free software; you can redistribute it and/or modify it under the    *
   9 * terms of the GNU General Public License as published by the Free Software    *
  10 * Foundation; either version 2 of the License, or (at your option) any later   *
  11 * version. In addition, you may distribute version of this program linked to   *
  12 * Motif or Open Motif. See README for details.                                 *
  13 *                                                                              *
  14 * This software is distributed in the hope that it will be useful, but WITHOUT *
  15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
  16 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License        *
  17 * for more details.                                                            *
  18 *                                                                              *
  19 * You should have received a copy of the GNU General Public License along with *
  20 * software; if not, write to the Free Software Foundation, Inc., 59 Temple     *
  21 * Place, Suite 330, Boston, MA  02111-1307 USA                                 *
  22 *                                                                              *
  23 * Nirvana Text Editor                                                          *
  24 * June 2, 1993                                                                 *
  25 *                                                                              *
  26 * Written by Suresh Ravoor (assisted by Mark Edel)                             *
  27 *                                                                              *
  28 *******************************************************************************/
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include "../config.h"
  32 #endif
  33
  34 #include "fontsel.h"
  35 #include "misc.h"
  36 #include "DialogF.h"
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <math.h>
  42
  43 #include <X11/Intrinsic.h>
  44 #include <Xm/Xm.h>
  45 #include <Xm/Form.h>
  46 #include <Xm/PushB.h>
  47 #include <Xm/List.h>
  48 #include <Xm/Label.h>
  49 #include <Xm/Text.h>
  50 #include <Xm/TextF.h>
  51 #include <Xm/ToggleB.h>
  52 #include <Xm/MessageB.h>
  53 #include <Xm/DialogS.h>
  54
  55 #ifdef HAVE_DEBUG_H
  56 #include "../debug.h"
  57 #endif
  58
  59 #define MAX_ARGS                        20
  60 #define MAX_NUM_FONTS                   32767
  61 #define MAX_FONT_NAME_LEN               256
  62 #define MAX_ENTRIES_IN_LIST             5000
  63 #define MAX_DISPLAY_SIZE                150
  64 #define DELIM                           '-'
  65 #define NUM_COMPONENTS_FONT_NAME        14
  66 #define TEMP_BUF_SIZE                   256
  67 #define DISPLAY_HEIGHT                  90
  68
  69 enum listSpecifier { NONE, FONT, STYLE, SIZE };
  70
  71
  72 /* local data structures and types */
  73
  74 typedef struct
  75 {
  76         Widget          form;           /* widget id */
  77         Widget          okButton;       /* widget id */
  78         Widget          cancelButton;   /* widget id */
  79         Widget          fontList;       /* widget id */
  80         Widget          styleList;      /* widget id */
  81         Widget          sizeList;       /* widget id */
  82         Widget          fontNameField;  /* widget id */
  83         Widget          sizeToggle;     /* widget id */
  84         Widget          propFontToggle; /* widget id */
  85         Widget          dispField;      /* widget id */
  86         char            **fontData;     /* font name info  */
  87         int             numFonts;       /* number of fonts */
  88         char            *sel1;          /* selection from list 1 */
  89         char            *sel2;          /* selection from list 2 */
  90         char            *sel3;          /* selection from list 3 */
  91         int             showPropFonts;  /* toggle state - show prop fonts */
  92         int             showSizeInPixels;/* toggle state - size in pixels  */
  93         char            *fontName;      /* current font name */
  94         XFontStruct     *oldFont;       /* font data structure for dispSample */
  95         XmFontList      oldFontList;    /* font data structure for dispSample */
  96         int     exitFlag;               /* used for program exit control */
  97         int     destroyedFlag;          /* used to prevent double destruction */
  98         Pixel   sampleFG;               /* Colors for the sample field */
  99         Pixel   sampleBG;
 100 }       xfselControlBlkType;
 101
 102
 103 /* local function prototypes */
 104
 105 static void     getStringComponent(const char *inStr, int pos, char *outStr);
 106 static void     setupScrollLists(int dontChange, xfselControlBlkType ctrlBlk);
 107 static int      notPropFont(const char *font);
 108 static int      styleMatch(xfselControlBlkType *ctrlBlk, const char *font);
 109 static int      sizeMatch(xfselControlBlkType *ctrlBlk, const char *font);
 110 static int      fontMatch(xfselControlBlkType *ctrlBlk, const char *font);
 111 static void     addItemToList(char **buf, const char *item, int *count);
 112 static void     getFontPart(const char *font, char *buff1);
 113 static void     getStylePart(const char *font, char *buff1);
 114 static void     getSizePart(const char *font, char *buff1, int inPixels);
 115 static void     propFontToggleAction(Widget widget,
 116                                      xfselControlBlkType *ctrlBlk,
 117                                      XmToggleButtonCallbackStruct *call_data);
 118 static void     sizeToggleAction(Widget widget,
 119                                  xfselControlBlkType *ctrlBlk,
 120                                  XmToggleButtonCallbackStruct *call_data);
 121 static void     fontAction(Widget widget, xfselControlBlkType *ctrlBlk,
 122                                  XmListCallbackStruct *call_data);
 123 static void     styleAction(Widget widget, xfselControlBlkType *ctrlBlk,
 124                                  XmListCallbackStruct *call_data);
 125 static void     sizeAction(Widget widget, xfselControlBlkType *ctrlBlk,
 126                                  XmListCallbackStruct *call_data);
 127 static void     choiceMade(xfselControlBlkType *ctrlBlk);
 128 static void     dispSample(xfselControlBlkType *ctrlBlk);
 129 static void     destroyCB(Widget widget, xfselControlBlkType *ctrlBlk,
 130                                  XmListCallbackStruct *call_data);
 131 static void     cancelAction(Widget widget, xfselControlBlkType *ctrlBlk,
 132                                  XmListCallbackStruct *call_data);
 133 static void     okAction(Widget widget, xfselControlBlkType *ctrlBlk,
 134                                  XmPushButtonCallbackStruct *call_data);
 135 static void     startupFont(xfselControlBlkType *ctrlBlk, const char *font);
 136 static void     setFocus(Widget w, xfselControlBlkType *ctrlBlk, XEvent *event,
 137                                                 Boolean *continueToDispatch);
 138 static void     FindBigFont(xfselControlBlkType *ctrlBlk, char *bigFont);
 139 static void     enableSample(xfselControlBlkType *ctrlBlk, Bool turn_on,
 140                              XmFontList *fontList);
 141
 142 /*******************************************************************************
 143 *                                                                              *
 144 *     FontSel ()                                                               *
 145 *                                                                              *
 146 *                                                                              *
 147 *            Function to put up a modal font selection dialog box. The purpose *
 148 *            of this routine is to allow the user to interactively view sample *
 149 *            fonts and to choose a font for current use.                       *
 150 *                                                                              *
 151 *     Arguments:                                                               *
 152 *                                                                              *
 153 *            Widget     parent          - parent widget ID                     *
 154 *                                                                              *
 155 *            int        showPropFont    - ONLY_FIXED : shows only fixed fonts  *
 156 *                                                      doesn't show prop font  *
 157 *                                                      toggle button also.     *
 158 *                                         PREF_FIXED : can select either fixed *
 159 *                                                      or proportional fonts;  *
 160 *                                                      but starting option is  *
 161 *                                                      Fixed fonts.            *
 162 *                                         PREF_PROP  : can select either fixed *
 163 *                                                      or proportional fonts;  *
 164 *                                                      but starting option is  *
 165 *                                                      proportional fonts.     *
 166 *                                                                              *
 167 *           char *      currFont        - ASCII string that contains the name  *
 168 *                                         of the currently selected font.      *
 169 *                                                                              *
 170 *           Pixel   sampleFG, sampleBG      - Foreground/Background colors in  *
 171 *                                               which to display the sample    *
 172 *                                               text.                          *
 173 *                                                                              *
 174 *                                                                              *
 175 *     Returns:                                                                 *
 176 *                                                                              *
 177 *           pointer to an ASCII character string that contains the name of     *
 178 *           the selected font (in X format for naming fonts); it is the users  *
 179 *           responsibility to free the space allocated to this string.         *
 180 *                                                                              *
 181 *     Comments:                                                                *
 182 *                                                                              *
 183 *           The calling function has to call the appropriate routines to set   *
 184 *           the current font to the one represented by the returned string.    *
 185 *                                                                              *
 186 *******************************************************************************/
 187
 188 char    *FontSel(Widget parent, int showPropFonts, const char *currFont,
 189             Pixel sampleFG, Pixel sampleBG)
 190 {
 191     Widget          dialog, form, okButton, cancelButton;
 192     Widget          styleList, sizeList, fontName, fontList;
 193     Widget          sizeToggle, propFontToggle = NULL, dispField;
 194     Widget          nameLabel, sampleLabel;
 195     Arg             args[MAX_ARGS];
 196     int             n;
 197     XmString        tempStr;
 198     char            bigFont[MAX_FONT_NAME_LEN];
 199     xfselControlBlkType ctrlBlk;
 200     Display         *theDisplay;
 201
 202     ctrlBlk.fontData    = XListFonts(XtDisplay(parent),
 203                                      "-*-*-*-*-*-*-*-*-*-*-*-*-*-*",
 204                                      MAX_NUM_FONTS, &ctrlBlk.numFonts);
 205     FindBigFont(&ctrlBlk, bigFont);
 206     ctrlBlk.oldFont = XLoadQueryFont(XtDisplay(parent), bigFont);
 207     ctrlBlk.oldFontList = XmFontListCreate(ctrlBlk.oldFont,
 208                                             XmSTRING_DEFAULT_CHARSET);
 209     ctrlBlk.sampleFG = sampleFG;
 210     ctrlBlk.sampleBG = sampleBG;
 211
 212     dialog  = CreateDialogShell(parent, "Font Selector", args, 0);
 213
 214     /*  Set up window sizes for form widget */
 215
 216     n = 0;
 217     XtSetArg(args[n], XmNautoUnmanage, FALSE); n++;
 218     XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
 219
 220     /*  Create form popup dialog widget */
 221
 222     form    = XtCreateWidget ("Font Selector", xmFormWidgetClass, dialog,
 223                               args, n);
 224
 225     /*  Create pushbutton widgets */
 226
 227     n = 0;
 228     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
 229     XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 230     XtSetArg(args[n], XmNbottomOffset, 4); n++;
 231     XtSetArg(args[n], XmNtopOffset, 1); n++;
 232     XtSetArg(args[n], XmNrightPosition, 45); n++;
 233     XtSetArg(args[n], XmNwidth, 110); n++;
 234     XtSetArg(args[n], XmNheight, 28); n++;
 235     XtSetArg(args[n], XmNshowAsDefault, TRUE); n++;
 236     okButton = XtCreateManagedWidget("OK", xmPushButtonWidgetClass, form,
 237                                       args, n);
 238
 239     n = 0;
 240     XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 241     XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
 242     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 243     XtSetArg(args[n], XmNtopWidget, okButton); n++;
 244     XtSetArg(args[n], XmNbottomWidget, okButton); n++;
 245     XtSetArg(args[n], XmNleftPosition, 55); n++;
 246     XtSetArg(args[n], XmNwidth, 110); n++;
 247     XtSetArg(args[n], XmNheight, 28); n++;
 248     cancelButton = XtCreateManagedWidget("Cancel", xmPushButtonWidgetClass,
 249                                          form, args, n);
 250
 251     /*  create font name text widget and the corresponding label */
 252
 253     n = 0;
 254     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 255     XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
 256     XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 257     XtSetArg(args[n], XmNbottomWidget, okButton); n++;
 258     XtSetArg(args[n], XmNleftPosition, 1); n++;
 259     XtSetArg(args[n], XmNrightPosition, 99); n++;
 260     XtSetArg(args[n], XmNeditable, True); n++;
 261     XtSetArg(args[n], XmNeditMode, XmSINGLE_LINE_EDIT); n++;
 262     XtSetArg(args[n], XmNmaxLength, MAX_FONT_NAME_LEN); n++;
 263     fontName = XtCreateManagedWidget("fontname", xmTextWidgetClass, form,
 264                                      args, n);
 265     RemapDeleteKey(fontName);   /* kludge to handle delete and BS */
 266
 267     n = 0;
 268     tempStr = XmStringCreate("Font Name:", XmSTRING_DEFAULT_CHARSET);
 269     XtSetArg(args[n], XmNlabelString, tempStr); n++;
 270     XtSetArg(args[n], XmNmnemonic, 'N'); n++;
 271     XtSetArg(args[n], XmNuserData, fontName); n++;
 272     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 273     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 274     XtSetArg(args[n], XmNleftWidget, fontName); n++;
 275     XtSetArg(args[n], XmNbottomWidget, fontName); n++;
 276     XtSetArg(args[n], XmNtopOffset, 1); n++;
 277     nameLabel = XtCreateManagedWidget("Font Name:", xmLabelWidgetClass,
 278                                       form, args, n);
 279     XmStringFree(tempStr);
 280
 281     /*  create sample display text field widget */
 282
 283     n = 0;
 284     XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
 285     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 286     XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 287     XtSetArg(args[n], XmNrightPosition, 99); n++;
 288     XtSetArg(args[n], XmNbottomWidget, nameLabel); n++;
 289     XtSetArg(args[n], XmNleftPosition, 1); n++;
 290     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
 291     XtSetArg(args[n], XmNvalue,
 292             "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789");
 293             n++;
 294     XtSetArg(args[n], XmNforeground, sampleFG); n++;
 295     XtSetArg(args[n], XmNbackground, sampleBG); n++;
 296     dispField = XtCreateManagedWidget(" ", xmTextFieldWidgetClass, form,
 297                                        args, n);
 298
 299     n = 0;
 300     tempStr = XmStringCreate("Sample:", XmSTRING_DEFAULT_CHARSET);
 301     XtSetArg(args[n], XmNlabelString, tempStr); n++;
 302     XtSetArg(args[n], XmNmnemonic, 'S'); n++;
 303     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 304     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 305     XtSetArg(args[n], XmNleftWidget, dispField); n++;
 306     XtSetArg(args[n], XmNbottomWidget, dispField); n++;
 307     XtSetArg(args[n], XmNtopOffset, 1); n++;
 308     sampleLabel = XtCreateManagedWidget("Font Name:", xmLabelWidgetClass,
 309             form, args, n);
 310     XmStringFree(tempStr);
 311
 312     /*  create toggle buttons */
 313
 314     n = 0;
 315     tempStr = XmStringCreate("Show Size in Points",
 316                               XmSTRING_DEFAULT_CHARSET);
 317     XtSetArg(args[n], XmNlabelString, tempStr); n++;
 318     XtSetArg(args[n], XmNmnemonic, 'P'); n++;
 319     XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
 320     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 321     XtSetArg(args[n], XmNleftPosition, 2); n++;
 322     XtSetArg(args[n], XmNtopOffset, 1); n++;
 323     XtSetArg(args[n], XmNbottomWidget, sampleLabel); n++;
 324     sizeToggle = XtCreateManagedWidget("sizetoggle",
 325                       xmToggleButtonWidgetClass, form, args, n);
 326     XmStringFree(tempStr);
 327
 328     if (showPropFonts != ONLY_FIXED)
 329     {
 330         n = 0;
 331         tempStr = XmStringCreate("Show Proportional Width Fonts",
 332                                  XmSTRING_DEFAULT_CHARSET);
 333         XtSetArg(args[n], XmNlabelString, tempStr); n++;
 334         XtSetArg(args[n], XmNmnemonic, 'W'); n++;
 335         XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 336         XtSetArg(args[n], XmNtopAttachment,
 337                         XmATTACH_OPPOSITE_WIDGET); n++;
 338         XtSetArg(args[n], XmNbottomAttachment,
 339                         XmATTACH_OPPOSITE_WIDGET); n++;
 340         XtSetArg(args[n], XmNrightPosition, 98); n++;
 341         XtSetArg(args[n], XmNtopWidget, sizeToggle); n++;
 342         XtSetArg(args[n], XmNbottomWidget, sizeToggle); n++;
 343         XtSetArg(args[n], XmNtopOffset, 1); n++;
 344         propFontToggle = XtCreateManagedWidget("propfonttoggle",
 345                             xmToggleButtonWidgetClass, form, args, n);
 346         XmStringFree(tempStr);
 347     }
 348
 349     /*  create scroll list widgets */
 350     /*  "Font" list */
 351
 352     n = 0;
 353     tempStr = XmStringCreate("Font:", XmSTRING_DEFAULT_CHARSET);
 354     XtSetArg(args[n], XmNlabelString, tempStr); n++;
 355     XtSetArg(args[n], XmNmnemonic, 'F'); n++;
 356     XtSetArg(args[n], XmNtopOffset, 2); n++;
 357     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
 358     XtSetArg(args[n], XmNleftAttachment, XmATTACH_POSITION); n++;
 359     XtSetArg(args[n], XmNleftPosition, 1); n++;
 360     nameLabel = XtCreateManagedWidget("Font:", xmLabelWidgetClass, form,
 361                                       args, n);
 362     XmStringFree(tempStr);
 363
 364     n = 0;
 365     XtSetArg(args[n], XmNvisibleItemCount, 15); n++;
 366     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
 367     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 368     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 369     XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 370     XtSetArg(args[n], XmNbottomWidget, sizeToggle); n++;
 371     XtSetArg(args[n], XmNtopWidget, nameLabel); n++;
 372     XtSetArg(args[n], XmNleftWidget, nameLabel); n++;
 373     XtSetArg(args[n], XmNrightPosition, 52); n++;
 374     fontList = XmCreateScrolledList(form, "fontlist", args, n);
 375     AddMouseWheelSupport(fontList);
 376     XtManageChild(fontList);
 377     XtVaSetValues(nameLabel, XmNuserData, fontList, NULL);
 378
 379     /* "Style" list */
 380
 381     n = 0;
 382     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
 383     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 384     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
 385     XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 386     XtSetArg(args[n], XmNtopWidget, nameLabel); n++;
 387     XtSetArg(args[n], XmNleftOffset, 5); n++;
 388     XtSetArg(args[n], XmNleftWidget, XtParent(fontList)); n++;
 389     XtSetArg(args[n], XmNbottomWidget, XtParent(fontList)); n++;
 390     XtSetArg(args[n], XmNrightPosition, 85); n++;
 391     styleList = XmCreateScrolledList(form, "stylelist", args, n);
 392     AddMouseWheelSupport(styleList);
 393     XtManageChild(styleList);
 394
 395     n = 0;
 396     tempStr = XmStringCreate("Style:", XmSTRING_DEFAULT_CHARSET);
 397     XtSetArg(args[n], XmNmnemonic, 'y'); n++;
 398     XtSetArg(args[n], XmNuserData, styleList); n++;
 399     XtSetArg(args[n], XmNlabelString, tempStr); n++;
 400     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 401     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 402     XtSetArg(args[n], XmNbottomWidget, XtParent(styleList)); n++;
 403     XtSetArg(args[n], XmNleftWidget, XtParent(styleList)); n++;
 404     XtCreateManagedWidget("Style:", xmLabelWidgetClass, form, args, n);
 405     XmStringFree(tempStr);
 406
 407     /*  "Size" list */
 408
 409     n = 0;
 410     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
 411     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
 412     XtSetArg(args[n], XmNrightAttachment, XmATTACH_POSITION); n++;
 413     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 414     XtSetArg(args[n], XmNtopWidget, nameLabel); n++;
 415     XtSetArg(args[n], XmNleftWidget, XtParent(styleList)); n++;
 416     XtSetArg(args[n], XmNbottomWidget, XtParent(fontList)); n++;
 417     XtSetArg(args[n], XmNleftOffset, 5); n++;
 418     XtSetArg(args[n], XmNrightPosition, 99); n++;
 419     sizeList = XmCreateScrolledList(form, "sizelist", args, n);
 420     AddMouseWheelSupport(sizeList);
 421     XtManageChild(sizeList);
 422
 423     n = 0;
 424     tempStr = XmStringCreate("Size:", XmSTRING_DEFAULT_CHARSET);
 425     XtSetArg(args[n], XmNlabelString, tempStr); n++;
 426     XtSetArg(args[n], XmNmnemonic, 'z'); n++;
 427     XtSetArg(args[n], XmNuserData, sizeList); n++;
 428     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
 429     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
 430     XtSetArg(args[n], XmNbottomWidget, XtParent(sizeList)); n++;
 431     XtSetArg(args[n], XmNleftWidget, XtParent(sizeList)); n++;
 432     XtCreateManagedWidget("Size:", xmLabelWidgetClass, form, args, n);
 433     XmStringFree(tempStr);
 434
 435     /*  update form widgets cancel button */
 436
 437     n = 0;
 438     XtSetArg(args[n], XmNcancelButton, cancelButton); n++;
 439     XtSetValues(form, args, n);
 440
 441
 442     /*  update application's control block structure */
 443
 444     ctrlBlk.form            = form;
 445     ctrlBlk.okButton        = okButton;
 446     ctrlBlk.cancelButton    = cancelButton;
 447     ctrlBlk.fontList        = fontList;
 448     ctrlBlk.styleList       = styleList;
 449     ctrlBlk.sizeList        = sizeList;
 450     ctrlBlk.fontNameField   = fontName;
 451     ctrlBlk.sizeToggle      = sizeToggle;
 452     if (showPropFonts != ONLY_FIXED)
 453         ctrlBlk.propFontToggle  = propFontToggle;
 454     ctrlBlk.dispField       = dispField;
 455     ctrlBlk.exitFlag        = FALSE;
 456     ctrlBlk.destroyedFlag   = FALSE;
 457     ctrlBlk.showPropFonts   = showPropFonts;
 458     ctrlBlk.showSizeInPixels = TRUE;
 459     ctrlBlk.sel1            = NULL;
 460     ctrlBlk.sel2            = NULL;
 461     ctrlBlk.sel3            = NULL;
 462     ctrlBlk.fontName        = NULL;
 463
 464     setupScrollLists(NONE, ctrlBlk);    /* update scroll lists */
 465
 466     if (showPropFonts == PREF_PROP)
 467         XmToggleButtonSetState(propFontToggle, TRUE, FALSE);
 468
 469     /*  Register callback functions */
 470
 471     if (showPropFonts != ONLY_FIXED)
 472         XtAddCallback(propFontToggle, XmNvalueChangedCallback,
 473                 (XtCallbackProc)propFontToggleAction, (char *)&ctrlBlk);
 474     XtAddCallback(sizeToggle, XmNvalueChangedCallback,
 475             (XtCallbackProc)sizeToggleAction, (char *)&ctrlBlk);
 476     XtAddCallback(fontList, XmNbrowseSelectionCallback,
 477             (XtCallbackProc)fontAction, (char *)&ctrlBlk);
 478     XtAddCallback(styleList, XmNbrowseSelectionCallback,
 479             (XtCallbackProc)styleAction, (char *)&ctrlBlk);
 480     XtAddCallback(sizeList, XmNbrowseSelectionCallback,
 481             (XtCallbackProc)sizeAction, (char *)&ctrlBlk);
 482     XtAddCallback(okButton, XmNactivateCallback,
 483             (XtCallbackProc)okAction, (char *)&ctrlBlk);
 484     XtAddCallback(cancelButton, XmNactivateCallback,
 485             (XtCallbackProc)cancelAction, (char *)&ctrlBlk);
 486
 487     /* add event handler to setup input focus at start to scroll list */
 488
 489     XtAddEventHandler(fontList, FocusChangeMask, FALSE,
 490             (XtEventHandler)setFocus, (char *)&ctrlBlk);
 491     XmProcessTraversal(fontList, XmTRAVERSE_CURRENT);
 492
 493     /*  setup tabgroups */
 494
 495     XmAddTabGroup(fontList);
 496     XmAddTabGroup(styleList);
 497     XmAddTabGroup(sizeList);
 498     XmAddTabGroup(sizeToggle);
 499     if (showPropFonts != ONLY_FIXED)
 500         XmAddTabGroup(propFontToggle);
 501     XmAddTabGroup(fontName);
 502     XmAddTabGroup(okButton);
 503     XmAddTabGroup(cancelButton);
 504
 505     /* Make sure that we don't try to access the dialog if the user
 506        destroyed it (possibly indirectly, by destroying the parent). */
 507     XtAddCallback(dialog, XmNdestroyCallback,
 508             (XtCallbackProc)destroyCB, (char *)&ctrlBlk);
 509
 510     /*  Link Motif Close option to cancel action */
 511
 512     AddMotifCloseCallback(dialog, (XtCallbackProc)cancelAction, &ctrlBlk);
 513
 514     /*  Handle dialog mnemonics  */
 515
 516     AddDialogMnemonicHandler(form, FALSE);
 517
 518     /*  Realize Widgets  */
 519
 520     ManageDialogCenteredOnPointer(form);
 521
 522     /* set up current font parameters */
 523
 524     if (currFont[0] != '\0')
 525         startupFont(&ctrlBlk, currFont);
 526
 527     /* Make sure that we can still access the display in case the form
 528        gets destroyed */
 529     theDisplay = XtDisplay(form);
 530
 531     /*  enter event loop */
 532
 533     while (! ctrlBlk.exitFlag && ! ctrlBlk.destroyedFlag)
 534         XtAppProcessEvent(XtWidgetToApplicationContext(form), XtIMAll);
 535
 536     if (! ctrlBlk.destroyedFlag) {
 537         /* Don't let the callback destroy the font name */
 538         XtRemoveCallback(dialog, XmNdestroyCallback,
 539                 (XtCallbackProc)destroyCB, (char *)&ctrlBlk);
 540         XtDestroyWidget(dialog);
 541     }
 542
 543     if (ctrlBlk.oldFont != NULL)
 544     {
 545         XFreeFont(theDisplay, ctrlBlk.oldFont);
 546         XmFontListFree(ctrlBlk.oldFontList);
 547     }
 548
 549     return(ctrlBlk.fontName);
 550 }
 551
 552
 553 /*  gets a specific substring from a string */
 554
 555 static void getStringComponent(const char *inStr, int pos, char *outStr)
 556 {
 557     int i, j;
 558
 559     *outStr = '\0';
 560
 561     if (pos > NUM_COMPONENTS_FONT_NAME)
 562     {
 563         fprintf(stderr, "Warning: getStringComponent being used for ");
 564         fprintf(stderr, "pos > %d\nIf such ", NUM_COMPONENTS_FONT_NAME);
 565         fprintf(stderr, "use is intended remove these warning lines\n");
 566     }
 567
 568     for (i = 0; (pos > 0) && (inStr[i] != '\0'); i++)
 569         if (inStr[i] == DELIM)
 570             pos--;
 571
 572     if (inStr[i] == '\0')
 573         return;
 574
 575     for (j = 0; (inStr[i] != DELIM) && (inStr[i] != '\0'); i++, j++)
 576         outStr[j] = inStr[i];
 577     outStr[j] = '\0';
 578 }
 579
 580
 581 /* parse through the fontlist data and set up the three scroll lists */
 582
 583 static void setupScrollLists(int dontChange, xfselControlBlkType ctrlBlk)
 584 {
 585     char        *itemBuf1[MAX_ENTRIES_IN_LIST];
 586     char        *itemBuf2[MAX_ENTRIES_IN_LIST];
 587     char        *itemBuf3[MAX_ENTRIES_IN_LIST];
 588     int         itemCount1, itemCount2, itemCount3;
 589     char        buff1[TEMP_BUF_SIZE];
 590     XmString    items[MAX_ENTRIES_IN_LIST];
 591     int         i;
 592
 593     itemCount1 = 0;
 594     itemCount2 = 0;
 595     itemCount3 = 0;
 596
 597     for (i = 0; i < ctrlBlk.numFonts && i < MAX_ENTRIES_IN_LIST; i++)
 598     {
 599         if ((dontChange != FONT) &&
 600             (styleMatch(&ctrlBlk, ctrlBlk.fontData[i])) &&
 601             (sizeMatch (&ctrlBlk, ctrlBlk.fontData[i])) &&
 602             ((ctrlBlk.showPropFonts == PREF_PROP) ||
 603              (notPropFont(ctrlBlk.fontData[i]))))
 604         {
 605             getFontPart(ctrlBlk.fontData[i], buff1);
 606             addItemToList(itemBuf1, buff1, &itemCount1);
 607         }
 608
 609         if ((dontChange != STYLE) &&
 610             (fontMatch(&ctrlBlk, ctrlBlk.fontData[i])) &&
 611             (sizeMatch (&ctrlBlk, ctrlBlk.fontData[i])) &&
 612             ((ctrlBlk.showPropFonts == PREF_PROP) ||
 613              (notPropFont(ctrlBlk.fontData[i]))))
 614         {
 615             getStylePart(ctrlBlk.fontData[i], buff1);
 616             addItemToList(itemBuf2, buff1, &itemCount2);
 617         }
 618
 619         if ((dontChange != SIZE) &&
 620             (fontMatch(&ctrlBlk, ctrlBlk.fontData[i])) &&
 621             (styleMatch (&ctrlBlk, ctrlBlk.fontData[i])) &&
 622             ((ctrlBlk.showPropFonts == PREF_PROP) ||
 623              (notPropFont(ctrlBlk.fontData[i]))))
 624         {
 625             getSizePart(ctrlBlk.fontData[i], buff1, ctrlBlk.showSizeInPixels);
 626             addItemToList(itemBuf3, buff1, &itemCount3);
 627         }
 628     }   /* end - for (i = 0; i < ctrlBlk.numFonts; i++) */
 629
 630     /*  recreate all three scroll lists where necessary */
 631     if (dontChange != FONT)
 632     {
 633         for (i = 0; i < itemCount1; i++)
 634         {
 635             items[i] = XmStringCreate(itemBuf1[i], XmSTRING_DEFAULT_CHARSET);
 636             XtFree(itemBuf1[i]);
 637         }
 638         XmListDeleteAllItems(ctrlBlk.fontList);
 639         XmListAddItems(ctrlBlk.fontList, items, itemCount1, 1);
 640         if (ctrlBlk.sel1 != NULL)
 641         {
 642             XmStringFree(items[0]);
 643             items[0] = XmStringCreate(ctrlBlk.sel1, XmSTRING_DEFAULT_CHARSET);
 644             XmListSelectItem(ctrlBlk.fontList, items[0], FALSE);
 645             XmListSetBottomItem(ctrlBlk.fontList, items[0]);
 646         }
 647         for (i = 0; i < itemCount1; i++)
 648             XmStringFree(items[i]);
 649     }
 650
 651     if (dontChange != STYLE)
 652     {
 653         for (i = 0; i < itemCount2; i++)
 654         {
 655             items[i] = XmStringCreate(itemBuf2[i], XmSTRING_DEFAULT_CHARSET);
 656             XtFree(itemBuf2[i]);
 657         }
 658         XmListDeleteAllItems(ctrlBlk.styleList);
 659         XmListAddItems(ctrlBlk.styleList, items, itemCount2, 1);
 660         if (ctrlBlk.sel2 != NULL)
 661         {
 662             XmStringFree(items[0]);
 663             items[0] = XmStringCreate(ctrlBlk.sel2, XmSTRING_DEFAULT_CHARSET);
 664             XmListSelectItem(ctrlBlk.styleList, items[0], FALSE);
 665             XmListSetBottomItem(ctrlBlk.styleList, items[0]);
 666         }
 667         for (i = 0; i < itemCount2; i++)
 668             XmStringFree(items[i]);
 669     }
 670
 671     if (dontChange != SIZE)
 672     {
 673         for (i = 0; i < itemCount3; i++)
 674         {
 675             items[i] = XmStringCreate(itemBuf3[i],
 676                               XmSTRING_DEFAULT_CHARSET);
 677             XtFree(itemBuf3[i]);
 678         }
 679         XmListDeleteAllItems(ctrlBlk.sizeList);
 680         XmListAddItems(ctrlBlk.sizeList, items, itemCount3, 1);
 681         if (ctrlBlk.sel3 != NULL)
 682         {
 683             XmStringFree(items[0]);
 684             items[0] = XmStringCreate(ctrlBlk.sel3, XmSTRING_DEFAULT_CHARSET);
 685             XmListSelectItem(ctrlBlk.sizeList, items[0], FALSE);
 686             XmListSetBottomItem(ctrlBlk.sizeList, items[0]);
 687         }
 688         for (i = 0; i < itemCount3; i++)
 689             XmStringFree(items[i]);
 690     }
 691 }
 692
 693
 694 /*  returns TRUE if argument is not name of a proportional font */
 695
 696 static int  notPropFont(const char *font)
 697 {
 698     char    buff1[TEMP_BUF_SIZE];
 699
 700     getStringComponent(font, 11, buff1);
 701     if ((strcmp(buff1, "p") == 0) || (strcmp(buff1, "P") == 0))
 702         return(FALSE);
 703     else
 704         return(TRUE);
 705 }
 706
 707
 708 /*  returns TRUE if the style portion of the font matches the currently
 709     selected style */
 710
 711 static int  styleMatch(xfselControlBlkType *ctrlBlk, const char *font)
 712 {
 713     char    buff[TEMP_BUF_SIZE];
 714
 715     if (ctrlBlk->sel2 == NULL)
 716         return(TRUE);
 717
 718     getStylePart(font, buff);
 719
 720     if (strcmp(buff, ctrlBlk->sel2) == 0)
 721         return(TRUE);
 722     else
 723         return(FALSE);
 724 }
 725
 726
 727 /*  returns TRUE if the size portion of the font matches the currently
 728     selected size */
 729
 730 static int  sizeMatch(xfselControlBlkType *ctrlBlk, const char *font)
 731 {
 732     char    buff[TEMP_BUF_SIZE];
 733
 734     if (ctrlBlk->sel3 == NULL)
 735         return(TRUE);
 736
 737     getSizePart(font, buff, ctrlBlk->showSizeInPixels);
 738     if (strcmp(buff, ctrlBlk->sel3) == 0)
 739         return(TRUE);
 740     else
 741         return(FALSE);
 742 }
 743
 744
 745 /*  returns TRUE if the font portion of the font matches the currently
 746     selected font */
 747
 748 static int  fontMatch(xfselControlBlkType *ctrlBlk, const char *font)
 749 {
 750     char    buff[TEMP_BUF_SIZE];
 751
 752     if (ctrlBlk->sel1 == NULL)
 753         return(TRUE);
 754
 755     getFontPart(font, buff);
 756     if (strcmp(buff, ctrlBlk->sel1) == 0)
 757         return(TRUE);
 758     else
 759         return(FALSE);
 760 }
 761
 762
 763 /*  inserts a string into correct sorted position in a list */
 764
 765 static void addItemToList(char **buf, const char *item, int *count)
 766 {
 767     int i, j;
 768
 769     if (*count == MAX_ENTRIES_IN_LIST)
 770     {
 771         fprintf(stderr, "Trying to add more than MAX_ENTRIES_IN_LIST ");
 772         fprintf(stderr, "(%d) entries to array\n", MAX_ENTRIES_IN_LIST);
 773         return;
 774     }
 775
 776     for (i = 0; i < *count; i++)
 777     {
 778         if (strcmp(buf[i], item) == 0)
 779             return;
 780         if (strcmp(buf[i], item) > 0)
 781             break;
 782     }
 783
 784     for (j = *count; j > i; j--)
 785         buf[j] = buf[j-1];
 786     buf[i] = XtMalloc(strlen(item) + 1);
 787     strcpy(buf[i], item);
 788     (*count)++;
 789 }
 790
 791
 792 /*  given a font name this function returns the part used in the first
 793     scroll list */
 794
 795 static void getFontPart(const char *font, char *buff1)
 796 {
 797     char    buff2[TEMP_BUF_SIZE], buff3[TEMP_BUF_SIZE];
 798     char    buff4[TEMP_BUF_SIZE];
 799
 800     getStringComponent(font, 2, buff1);
 801     getStringComponent(font, 1, buff2);
 802
 803     sprintf(buff3, "%s (%s", buff1, buff2);
 804
 805     getStringComponent(font, 13, buff1);
 806     getStringComponent(font, 14, buff4);
 807
 808     if (((strncmp(buff1, "iso8859", 7) == 0) ||
 809          (strncmp(buff1, "ISO8859", 7) == 0)) && (strcmp(buff4, "1") == 0))
 810         sprintf(buff1, "%s)", buff3);
 811     else
 812     {
 813         sprintf(buff2, "%s, %s,", buff3, buff1);
 814         sprintf(buff1, "%s %s)", buff2, buff4);
 815     }
 816 }
 817
 818
 819 /*  given a font name this function returns the part used in the second
 820     scroll list */
 821
 822 static void getStylePart(const char *font, char *buff1)
 823 {
 824     char    buff2[TEMP_BUF_SIZE], buff3[TEMP_BUF_SIZE];
 825
 826     getStringComponent(font, 3, buff3);
 827     getStringComponent(font, 5, buff2);
 828
 829     if ((strcmp(buff2, "normal") != 0) && (strcmp(buff2, "Normal") != 0) &&
 830         (strcmp(buff2, "NORMAL") != 0))
 831         sprintf(buff1, "%s %s", buff3, buff2);
 832     else
 833         strcpy(buff1, buff3);
 834
 835     getStringComponent(font, 6, buff2);
 836
 837     if (buff2[0] != '\0')
 838         sprintf(buff3, "%s %s", buff1, buff2);
 839     else
 840         strcpy(buff3, buff1);
 841
 842     getStringComponent(font, 4, buff2);
 843
 844     if ((strcmp(buff2, "o") == 0) || (strcmp(buff2, "O") == 0))
 845         sprintf(buff1, "%s oblique", buff3);
 846     else if ((strcmp(buff2, "i") == 0) || (strcmp(buff2, "I") == 0))
 847         sprintf(buff1, "%s italic", buff3);
 848
 849     if (strcmp(buff1, " ") == 0)
 850         strcpy(buff1, "-");
 851 }
 852
 853
 854 /*  given a font name this function returns the part used in the third
 855     scroll list */
 856
 857 static void getSizePart(const char *font, char *buff1, int inPixels)
 858 {
 859     int size;
 860
 861     if (inPixels)
 862     {
 863         getStringComponent(font, 7, buff1);
 864         size = atoi(buff1);
 865         sprintf(buff1, "%2d", size);
 866     }
 867     else
 868     {
 869         double temp;
 870
 871         getStringComponent(font, 8, buff1);
 872         size = atoi(buff1);
 873         temp = (double)size / 10.0;
 874         if (buff1[strlen(buff1) - 1] == '0')
 875         {
 876             size = (int)floor(temp+0.5);
 877             sprintf(buff1, "%2d", size);
 878         }
 879         else
 880             sprintf(buff1, "%4.1f", temp);
 881     }
 882 }
 883
 884
 885 /*  Call back functions start from here - suffix Action in the function name
 886     is for the callback function for the corresponding widget */
 887
 888 static void propFontToggleAction(Widget widget,
 889                      xfselControlBlkType *ctrlBlk,
 890                      XmToggleButtonCallbackStruct *call_data)
 891 {
 892     if (call_data->reason == XmCR_VALUE_CHANGED)
 893     {
 894         if (ctrlBlk->showPropFonts == PREF_FIXED)
 895             ctrlBlk->showPropFonts = PREF_PROP;
 896         else
 897             ctrlBlk->showPropFonts = PREF_FIXED;
 898
 899         if (ctrlBlk->sel1 != NULL)
 900             XtFree(ctrlBlk->sel1);
 901         ctrlBlk->sel1 = NULL;
 902
 903         if (ctrlBlk->sel2 != NULL)
 904             XtFree(ctrlBlk->sel2);
 905         ctrlBlk->sel2 = NULL;
 906
 907         if (ctrlBlk->sel3 != NULL)
 908             XtFree(ctrlBlk->sel3);
 909         ctrlBlk->sel3 = NULL;
 910
 911         setupScrollLists(NONE, *ctrlBlk);
 912
 913         XmTextSetString(ctrlBlk->fontNameField, "");
 914         enableSample(ctrlBlk, False, NULL);
 915     }
 916 }
 917
 918
 919 static void sizeToggleAction(Widget widget,
 920                  xfselControlBlkType *ctrlBlk,
 921                  XmToggleButtonCallbackStruct *call_data)
 922 {
 923     int         i, makeSelection;
 924     char        newSize[10];
 925     XmString    str;
 926
 927     if (call_data->reason == XmCR_VALUE_CHANGED)
 928     {
 929         makeSelection = (ctrlBlk->sel3 != NULL);
 930
 931         for (i = 0; (makeSelection) && (i < ctrlBlk->numFonts); i++)
 932             if ((fontMatch(ctrlBlk, ctrlBlk->fontData[i])) &&
 933                 (styleMatch(ctrlBlk, ctrlBlk->fontData[i])) &&
 934                 (sizeMatch(ctrlBlk, ctrlBlk->fontData[i])))
 935             {
 936                 getSizePart(ctrlBlk->fontData[i], newSize,
 937                             !ctrlBlk->showSizeInPixels);
 938                 break;
 939             }
 940
 941         if (ctrlBlk->showSizeInPixels)
 942             ctrlBlk->showSizeInPixels = FALSE;
 943         else
 944             ctrlBlk->showSizeInPixels = TRUE;
 945
 946         if (ctrlBlk->sel3 != NULL)
 947             XtFree(ctrlBlk->sel3);
 948
 949         ctrlBlk->sel3 = NULL;
 950         setupScrollLists(NONE, *ctrlBlk);
 951
 952         if (makeSelection)
 953         {
 954             str = XmStringCreate(newSize, XmSTRING_DEFAULT_CHARSET);
 955             XmListSelectItem(ctrlBlk->sizeList, str, TRUE);
 956             XmListSetBottomItem(ctrlBlk->sizeList, str);
 957             XmStringFree(str);
 958         }
 959     }
 960 }
 961
 962
 963 static void enableSample(xfselControlBlkType *ctrlBlk, Bool turn_on,
 964         XmFontList *fontList)
 965 {
 966     int n=0;
 967     Arg args[4];
 968
 969     XtSetArg(args[n], XmNeditable, turn_on); n++;
 970     XtSetArg(args[n], XmNcursorPositionVisible, turn_on); n++;
 971     if( turn_on ) {
 972         if( !fontList ) {
 973             fprintf(stderr, "nedit: Internal error in fontsel.c, line %i\n", \
 974                     __LINE__);
 975         } else {
 976             XtSetArg(args[n], XmNfontList, *fontList); n++;
 977         }
 978         XtSetArg(args[n], XmNforeground, ctrlBlk->sampleFG); n++;
 979     } else {
 980         XtSetArg(args[n], XmNforeground, ctrlBlk->sampleBG); n++;
 981     }
 982     XtSetValues(ctrlBlk->dispField, args, n);
 983     /* Make sure the sample area gets resized if the font size changes */
 984     XtUnmanageChild(ctrlBlk->dispField);
 985     XtManageChild(ctrlBlk->dispField);
 986 }
 987
 988
 989 static void fontAction(Widget widget, xfselControlBlkType *ctrlBlk,
 990                  XmListCallbackStruct *call_data)
 991 {
 992     char    *sel;
 993
 994     XmStringGetLtoR(call_data->item, XmSTRING_DEFAULT_CHARSET, &sel);
 995
 996     if (ctrlBlk->sel1 == NULL)
 997     {
 998         ctrlBlk->sel1 = XtMalloc(strlen(sel) + 1);
 999         strcpy(ctrlBlk->sel1, sel);
1000     }
1001     else
1002     {
1003         if (strcmp(ctrlBlk->sel1, sel) == 0)
1004         {           /* Unselecting current selection */
1005             XtFree(ctrlBlk->sel1);
1006             ctrlBlk->sel1 = NULL;
1007             XmListDeselectItem(widget, call_data->item);
1008         }
1009         else
1010         {
1011             XtFree(ctrlBlk->sel1);
1012             ctrlBlk->sel1 = XtMalloc(strlen(sel) + 1);
1013             strcpy(ctrlBlk->sel1, sel);
1014         }
1015     }
1016
1017     XtFree(sel);
1018     setupScrollLists(FONT, *ctrlBlk);
1019     if ((ctrlBlk->sel1 != NULL) && (ctrlBlk->sel2 != NULL) &&
1020         (ctrlBlk->sel3 != NULL))
1021         choiceMade(ctrlBlk);
1022     else
1023     {
1024         enableSample(ctrlBlk, False, NULL);
1025         XmTextSetString(ctrlBlk->fontNameField, "");
1026     }
1027 }
1028
1029
1030 static void styleAction(Widget widget, xfselControlBlkType *ctrlBlk,
1031                  XmListCallbackStruct *call_data)
1032 {
1033     char    *sel;
1034
1035     XmStringGetLtoR(call_data->item, XmSTRING_DEFAULT_CHARSET, &sel);
1036
1037     if (ctrlBlk->sel2 == NULL)
1038     {
1039         ctrlBlk->sel2 = XtMalloc(strlen(sel) + 1);
1040         strcpy(ctrlBlk->sel2, sel);
1041     }
1042     else
1043     {
1044         if (strcmp(ctrlBlk->sel2, sel) == 0)
1045         {           /* unselecting current selection */
1046             XtFree(ctrlBlk->sel2);
1047             ctrlBlk->sel2 = NULL;
1048             XmListDeselectItem(widget, call_data->item);
1049         }
1050         else
1051         {
1052             XtFree(ctrlBlk->sel2);
1053             ctrlBlk->sel2 = XtMalloc(strlen(sel) + 1);
1054             strcpy(ctrlBlk->sel2, sel);
1055         }
1056     }
1057
1058     XtFree(sel);
1059     setupScrollLists(STYLE, *ctrlBlk);
1060     if ((ctrlBlk->sel1 != NULL) && (ctrlBlk->sel2 != NULL) &&
1061         (ctrlBlk->sel3 != NULL))
1062         choiceMade(ctrlBlk);
1063     else
1064     {
1065         enableSample(ctrlBlk, False, NULL);
1066         XmTextSetString(ctrlBlk->fontNameField, "");
1067     }
1068 }
1069
1070 static void sizeAction(Widget widget, xfselControlBlkType *ctrlBlk,
1071                  XmListCallbackStruct *call_data)
1072 {
1073     char    *sel;
1074
1075     XmStringGetLtoR(call_data->item, XmSTRING_DEFAULT_CHARSET, &sel);
1076
1077     if (ctrlBlk->sel3 == NULL)
1078     {
1079         ctrlBlk->sel3 = XtMalloc(strlen(sel) + 1);
1080         strcpy(ctrlBlk->sel3, sel);
1081     }
1082     else
1083     {
1084         if (strcmp(ctrlBlk->sel3, sel) == 0)
1085         {           /* unselecting current selection */
1086             XtFree(ctrlBlk->sel3);
1087             ctrlBlk->sel3 = NULL;
1088             XmListDeselectItem(widget, call_data->item);
1089         }
1090         else
1091         {
1092             XtFree(ctrlBlk->sel3);
1093             ctrlBlk->sel3 = XtMalloc(strlen(sel) + 1);
1094             strcpy(ctrlBlk->sel3, sel);
1095         }
1096     }
1097
1098     XtFree(sel);
1099     setupScrollLists(SIZE, *ctrlBlk);
1100     if ((ctrlBlk->sel1 != NULL) && (ctrlBlk->sel2 != NULL) &&
1101         (ctrlBlk->sel3 != NULL))
1102         choiceMade(ctrlBlk);
1103     else
1104     {
1105         enableSample(ctrlBlk, False, NULL);
1106         XmTextSetString(ctrlBlk->fontNameField, "");
1107     }
1108 }
1109
1110 /*  function called when all three choices have been made; sets up font
1111     name and displays sample font */
1112
1113 static void choiceMade(xfselControlBlkType *ctrlBlk)
1114 {
1115     int i;
1116
1117     if (ctrlBlk->fontName != NULL)
1118         XtFree(ctrlBlk->fontName);
1119     ctrlBlk->fontName = NULL;
1120
1121     for (i = 0; i < ctrlBlk->numFonts; i++)
1122     {
1123         if ((fontMatch(ctrlBlk, ctrlBlk->fontData[i])) &&
1124             (styleMatch(ctrlBlk, ctrlBlk->fontData[i])) &&
1125             (sizeMatch (ctrlBlk, ctrlBlk->fontData[i])))
1126         {
1127             ctrlBlk->fontName = XtMalloc(
1128                           strlen(ctrlBlk->fontData[i]) + 1);
1129             strcpy(ctrlBlk->fontName, ctrlBlk->fontData[i]);
1130             break;
1131         }
1132     }
1133
1134     if (ctrlBlk->fontName != NULL)
1135     {
1136         XmTextSetString(ctrlBlk->fontNameField, ctrlBlk->fontName);
1137         dispSample(ctrlBlk);
1138     }
1139     else
1140     {
1141         DialogF (DF_ERR, ctrlBlk->form, 1, "Font Specification",
1142                 "Invalid Font Specification", "OK");
1143     }
1144 }
1145
1146
1147 /*  loads selected font and displays sample text in that font */
1148
1149 static void dispSample(xfselControlBlkType *ctrlBlk)
1150 {
1151     XFontStruct     *font;
1152     XmFontList      fontList;
1153     Display         *display;
1154
1155     display     = XtDisplay(ctrlBlk->form);
1156     font        = XLoadQueryFont(display, ctrlBlk->fontName);
1157     fontList    = XmFontListCreate(font, XmSTRING_DEFAULT_CHARSET);
1158
1159     enableSample(ctrlBlk, True, &fontList);
1160
1161     if (ctrlBlk->oldFont != NULL)
1162     {
1163         XFreeFont(display, ctrlBlk->oldFont);
1164         XmFontListFree(ctrlBlk->oldFontList);
1165     }
1166     ctrlBlk->oldFont    = font;
1167     ctrlBlk->oldFontList    = fontList;
1168 }
1169
1170
1171 static void destroyCB(Widget widget, xfselControlBlkType *ctrlBlk,
1172                  XmListCallbackStruct *call_data)
1173 {
1174     /* Prevent double destruction of the font selection dialog */
1175     ctrlBlk->destroyedFlag = TRUE;
1176     cancelAction(widget, ctrlBlk, call_data);
1177 }
1178
1179 static void cancelAction(Widget widget, xfselControlBlkType *ctrlBlk,
1180                  XmListCallbackStruct *call_data)
1181 {
1182     if (ctrlBlk->sel1 != NULL)
1183         XtFree(ctrlBlk->sel1);
1184     if (ctrlBlk->sel2 != NULL)
1185         XtFree(ctrlBlk->sel2);
1186     if (ctrlBlk->sel3 != NULL)
1187         XtFree(ctrlBlk->sel3);
1188     if (ctrlBlk->fontName != NULL)
1189         XtFree(ctrlBlk->fontName);
1190
1191     ctrlBlk->fontName = NULL;
1192     XFreeFontNames(ctrlBlk->fontData);
1193
1194     ctrlBlk->exitFlag = TRUE;
1195 }
1196
1197
1198 static void okAction(Widget widget, xfselControlBlkType *ctrlBlk,
1199                  XmPushButtonCallbackStruct *call_data)
1200 {
1201     char    *fontPattern;
1202     char    **fontName;
1203     int i;
1204
1205     fontPattern = XmTextGetString(ctrlBlk->fontNameField);
1206     fontName    = XListFonts(XtDisplay(ctrlBlk->form), fontPattern, 1, &i);
1207     XtFree(fontPattern);
1208
1209     if (i != 1)
1210     {
1211         DialogF (DF_ERR, ctrlBlk->okButton, 1, "Font Specification",
1212                 "Invalid Font Specification", "OK");
1213         XFreeFontNames(fontName);
1214     }
1215     else
1216     {
1217         if (ctrlBlk->fontName != NULL)
1218             XtFree(ctrlBlk->fontName);
1219         ctrlBlk->fontName = XtMalloc(strlen(fontName[0]) + 1);
1220         strcpy(ctrlBlk->fontName, fontName[0]);
1221
1222         if (ctrlBlk->sel1 != NULL)
1223             XtFree(ctrlBlk->sel1);
1224         if (ctrlBlk->sel2 != NULL)
1225             XtFree(ctrlBlk->sel2);
1226         if (ctrlBlk->sel3 != NULL)
1227             XtFree(ctrlBlk->sel3);
1228
1229         XFreeFontNames(fontName);
1230         XFreeFontNames(ctrlBlk->fontData);
1231
1232         ctrlBlk->exitFlag = TRUE;
1233     }
1234 }
1235
1236
1237 /*  if current font is passed as an argument then this function is
1238     invoked and sets up initial entries */
1239
1240 static void startupFont(xfselControlBlkType *ctrlBlk, const char *font)
1241 {
1242     int         i;
1243     char        **fontName;
1244     char        part[TEMP_BUF_SIZE];
1245     XmString    str;
1246
1247     fontName = XListFonts(XtDisplay(ctrlBlk->form), font, 1, &i);
1248
1249     if (i == 0)
1250     {           /*  invalid font passed in at startup */
1251         XFreeFontNames(fontName);
1252         return;
1253     }
1254
1255     ctrlBlk->fontName = XtMalloc(strlen(fontName[0]) + 1);
1256     strcpy(ctrlBlk->fontName, fontName[0]);
1257
1258     getFontPart(fontName[0], part);
1259     XFreeFontNames(fontName);
1260     str = XmStringCreate(part, XmSTRING_DEFAULT_CHARSET);
1261     XmListSetBottomItem(ctrlBlk->fontList, str);
1262     XmListSelectItem(ctrlBlk->fontList, str, TRUE);
1263     XmListSelectItem(ctrlBlk->fontList, str, TRUE);
1264     XmStringFree(str);
1265
1266     dispSample(ctrlBlk);
1267     XmTextSetString(ctrlBlk->fontNameField, ctrlBlk->fontName);
1268 }
1269
1270
1271 /*  hacked code to move initial input focus to first scroll list and at the
1272     same time have the OK button as the default button */
1273
1274 static void     setFocus(Widget w, xfselControlBlkType *ctrlBlk, XEvent *event,
1275                         Boolean *continueToDispatch)
1276 {
1277     int n;
1278     Arg args[2];
1279
1280     *continueToDispatch = TRUE;
1281
1282     n = 0;
1283     XtSetArg(args[n], XmNdefaultButton, ctrlBlk->okButton); n++;
1284     XtSetValues(ctrlBlk->form, args, n);
1285 }
1286
1287
1288 /*  finds the name of the biggest font less than the given limit
1289     MAX_DISPLAY_SIZE used to set up the initial height of the display widget
1290 */
1291
1292 static void FindBigFont(xfselControlBlkType *ctrlBlk, char *bigFont)
1293 {
1294     int     i, maxSize, ind = -1, size;
1295     char    sizeStr[10];
1296
1297     for (i = 0, maxSize = 0; i < ctrlBlk->numFonts; i++)
1298     {
1299         getStringComponent(ctrlBlk->fontData[i], 7, sizeStr);
1300         size = atoi(sizeStr);
1301         if ((size > maxSize) && (size < MAX_DISPLAY_SIZE))
1302         {
1303             ind   = i;
1304             maxSize = size;
1305         }
1306     }
1307     if (ind >= 0) {
1308         strcpy(bigFont, ctrlBlk->fontData[ind]);
1309     }
1310     else {
1311         bigFont[0] = 0;
1312     }
1313 }