Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 4884 insertions, 0 deletions

diff --git a/nx-X11/lib/dpstk/FontSB.c b/nx-X11/lib/dpstk/FontSB.c
new file mode 100644
index 000000000..a529f3af0
--- /dev/null
+++ b/nx-X11/lib/dpstk/FontSB.c
@@ -0,0 +1,4884 @@
+/* 
+ * FontSB.c
+ *
+ * (c) Copyright 1991-1994 Adobe Systems Incorporated.
+ * All rights reserved.
+ * 
+ * Permission to use, copy, modify, distribute, and sublicense this software
+ * and its documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notices appear in all copies and that
+ * both those copyright notices and this permission notice appear in
+ * supporting documentation and that the name of Adobe Systems Incorporated
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  No trademark license
+ * to use the Adobe trademarks is hereby granted.  If the Adobe trademark
+ * "Display PostScript"(tm) is used to describe this software, its
+ * functionality or for any other purpose, such use shall be limited to a
+ * statement that this software works in conjunction with the Display
+ * PostScript system.  Proper trademark attribution to reflect Adobe's
+ * ownership of the trademark shall be given whenever any such reference to
+ * the Display PostScript system is made.
+ * 
+ * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
+ * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
+ * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON- INFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO EVENT SHALL ADOBE BE LIABLE
+ * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  ADOBE WILL NOT
+ * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
+ * 
+ * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
+ * Incorporated which may be registered in certain jurisdictions
+ * 
+ * Author:  Adobe Systems Incorporated
+ */
+/* $XFree86$ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <math.h>
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <Xm/Xm.h>
+
+/* There are no words to describe how I feel about having to do this */
+
+#if XmVersion > 1001		
+#include <Xm/ManagerP.h>
+#else
+#include <Xm/XmP.h>
+#endif
+
+#include <Xm/Form.h>
+#include <Xm/List.h>
+#include <Xm/Label.h>
+#include <Xm/LabelG.h>
+#include <Xm/PushB.h>
+#include <Xm/PanedW.h>
+#include <Xm/PushBG.h>
+#include <Xm/SeparatoG.h>
+#include <Xm/TextF.h>
+#include <Xm/RowColumn.h>
+#include <Xm/DrawingA.h>
+#include <Xm/MessageB.h>
+#include <DPS/dpsXclient.h>
+#include "dpsXcommonI.h"
+#include <DPS/dpsXcommon.h>
+#include <DPS/dpsXshare.h>
+#include <DPS/PSres.h>
+#include <DPS/FontSBP.h>
+#include "FSBwraps.h"
+#include "FontSBI.h"
+#include <DPS/FontSample.h>
+#include <DPS/FontCreato.h>
+#include <pwd.h>
+
+#define PATH_BUF_SIZE 1024
+
+/* Turn a string into a compound string */
+#define UnsharedCS(str) XmStringCreate(str, XmSTRING_DEFAULT_CHARSET)
+#define CS(str, w) _FSBCreateSharedCS(str, w)
+static XmString CSempty;
+
+/* Create a canonical representation of a string, and as a side effect
+   make sure the string is in permanent storage.  This implementation may
+   not work under all Xlibs */
+
+#define Canonical(str) XrmQuarkToString(XrmStringToQuark(str))
+
+static float defaultSizeList[] = {
+#ifndef DEFAULT_SIZE_LIST
+    8, 10, 12, 14, 16, 18, 24, 36, 48, 72
+#else
+	DEFAULT_SIZE_LIST
+#endif /* DEFAULT_SIZE_LIST */
+};
+
+#ifndef DEFAULT_SIZE_LIST_COUNT
+#define DEFAULT_SIZE_LIST_COUNT 10
+#endif /* DEFAULT_SIZE_LIST_COUNT */
+
+#ifndef DEFAULT_SIZE
+static float default_size = 12.0;
+#else
+static float default_size = DEFAULT_SIZE
+#endif /* DEFAULT_SIZE */
+
+#ifndef DEFAULT_RESOURCE_PATH
+#define DEFAULT_RESOURCE_PATH NULL
+#endif /* DEFAULT_RESOURCE_PATH */
+
+#ifndef DEFAULT_MAX_PENDING
+#define DEFAULT_MAX_PENDING 10
+#endif /* DEFAULT_MAX_PENDING */
+
+#define Offset(field) XtOffsetOf(FontSelectionBoxRec, fsb.field)
+
+static XtResource resources[] = {
+    {XtNcontext, XtCContext, XtRDPSContext, sizeof(DPSContext),
+	Offset(context), XtRDPSContext, (XtPointer) NULL},
+    {XtNpreviewString, XtCPreviewString, XtRString, sizeof(String),
+	Offset(preview_string), XtRString, (XtPointer) NULL},
+    {XtNsizes, XtCSizes, XtRFloatList, sizeof(float*),
+	Offset(sizes), XtRImmediate, (XtPointer) defaultSizeList},
+    {XtNsizeCount, XtCSizeCount, XtRInt, sizeof(int),
+	Offset(size_count), XtRImmediate, (XtPointer) DEFAULT_SIZE_LIST_COUNT},
+    {XtNdefaultResourcePath, XtCDefaultResourcePath, XtRString, sizeof(String),
+	Offset(default_resource_path), XtRImmediate,
+	(XtPointer) DEFAULT_RESOURCE_PATH},
+    {XtNresourcePathOverride, XtCResourcePathOverride,
+	XtRString, sizeof(String),
+	Offset(resource_path_override), XtRString, (XtPointer) NULL},
+    {XtNuseFontName, XtCUseFontName, XtRBoolean, sizeof(Boolean),
+	Offset(use_font_name), XtRImmediate, (XtPointer) True},
+    {XtNfontName, XtCFontName, XtRString, sizeof(String),
+	Offset(font_name), XtRString, (XtPointer) NULL},
+    {XtNfontFamily, XtCFontFamily, XtRString, sizeof(String),
+	Offset(font_family), XtRString, (XtPointer) NULL},
+    {XtNfontFace, XtCFontFace, XtRString, sizeof(String),
+	Offset(font_face), XtRString, (XtPointer) NULL},
+    {XtNfontBlend, XtCFontBlend, XtRString, sizeof(String),
+	Offset(font_blend), XtRString, (XtPointer) NULL},
+    {XtNfontSize, XtCFontSize, XtRFloat, sizeof(String),
+	Offset(font_size), XtRFloat, (XtPointer) &default_size},
+    {XtNfontNameMultiple, XtCFontNameMultiple, XtRBoolean, sizeof(Boolean),
+	Offset(font_name_multiple), XtRImmediate, (XtPointer) False},
+    {XtNfontFamilyMultiple, XtCFontFamilyMultiple, XtRBoolean, sizeof(Boolean),
+	Offset(font_family_multiple), XtRImmediate, (XtPointer) False},
+    {XtNfontFaceMultiple, XtCFontFaceMultiple, XtRBoolean, sizeof(Boolean),
+	Offset(font_face_multiple), XtRImmediate, (XtPointer) False},
+    {XtNfontSizeMultiple, XtCFontSizeMultiple, XtRBoolean, sizeof(Boolean),
+	Offset(font_size_multiple), XtRImmediate, (XtPointer) False},
+    {XtNgetServerFonts, XtCGetServerFonts, XtRBoolean, sizeof(Boolean),
+	Offset(get_server_fonts), XtRImmediate, (XtPointer) True},
+    {XtNgetAFM, XtCGetAFM, XtRBoolean, sizeof(Boolean),
+	Offset(get_afm), XtRImmediate, (XtPointer) False},
+    {XtNautoPreview, XtCAutoPreview, XtRBoolean, sizeof(Boolean),
+	Offset(auto_preview), XtRImmediate, (XtPointer) True},
+    {XtNpreviewOnChange, XtCPreviewOnChange, XtRBoolean, sizeof(Boolean),
+	Offset(preview_on_change), XtRImmediate, (XtPointer) True},
+    {XtNundefUnusedFonts, XtCUndefUnusedFonts, XtRBoolean, sizeof(Boolean),
+	Offset(undef_unused_fonts), XtRImmediate, (XtPointer) True},
+    {XtNmaxPendingDeletes, XtCMaxPendingDeletes, XtRCardinal, sizeof(Cardinal),
+	Offset(max_pending_deletes), XtRImmediate,
+	(XtPointer) DEFAULT_MAX_PENDING},
+    {XtNmakeFontsShared, XtCMakeFontsShared, XtRBoolean, sizeof(Boolean),
+	Offset(make_fonts_shared), XtRImmediate, (XtPointer) True},
+    {XtNshowSampler, XtCShowSampler, XtRBoolean, sizeof(Boolean),
+	Offset(show_sampler), XtRImmediate, (XtPointer) False},
+    {XtNshowSamplerButton, XtCShowSamplerButton, XtRBoolean, sizeof(Boolean),
+	Offset(show_sampler_button), XtRImmediate, (XtPointer) True},
+    {XtNtypographicSort, XtCTypographicSort, XtRBoolean, sizeof(Boolean),
+	Offset(typographic_sort), XtRImmediate, (XtPointer) True},
+
+    {XtNokCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(ok_callback), XtRCallback, (XtPointer) NULL},
+    {XtNapplyCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(apply_callback), XtRCallback, (XtPointer) NULL},
+    {XtNresetCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(reset_callback), XtRCallback, (XtPointer) NULL},
+    {XtNcancelCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(cancel_callback), XtRCallback, (XtPointer) NULL},
+    {XtNvalidateCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(validate_callback), XtRCallback, (XtPointer) NULL},
+    {XtNfaceSelectCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(face_select_callback), XtRCallback, (XtPointer) NULL},
+    {XtNcreateSamplerCallback, XtCCallback, XtRCallback,
+	sizeof(XtCallbackList), Offset(create_sampler_callback),
+	XtRCallback, (XtPointer) NULL},
+    {XtNcreateCreatorCallback, XtCCallback, XtRCallback,
+	sizeof(XtCallbackList), Offset(create_creator_callback),
+	XtRCallback, (XtPointer) NULL},
+    {XtNvalueChangedCallback, XtCCallback, XtRCallback, sizeof(XtCallbackList),
+	Offset(value_changed_callback), XtRCallback, (XtPointer) NULL},
+
+    {XtNpaneChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(pane_child), XtRWidget, (XtPointer) NULL},
+    {XtNpreviewChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(preview_child), XtRWidget, (XtPointer) NULL},
+    {XtNpanelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(panel_child), XtRWidget, (XtPointer) NULL},
+    {XtNfamilyLabelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(family_label_child), XtRWidget, (XtPointer) NULL},
+    {XtNfamilyMultipleLabelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(family_multiple_label_child), XtRWidget, (XtPointer) NULL},
+    {XtNfamilyScrolledListChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(family_scrolled_list_child), XtRWidget, (XtPointer) NULL},
+    {XtNfaceLabelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(face_label_child), XtRWidget, (XtPointer) NULL},
+    {XtNfaceMultipleLabelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(face_multiple_label_child), XtRWidget, (XtPointer) NULL},
+    {XtNfaceScrolledListChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(face_scrolled_list_child), XtRWidget, (XtPointer) NULL},
+    {XtNsizeLabelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(size_label_child), XtRWidget, (XtPointer) NULL},
+    {XtNsizeTextFieldChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(size_text_field_child), XtRWidget, (XtPointer) NULL},
+    {XtNsizeOptionMenuChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(size_option_menu_child), XtRWidget, (XtPointer) NULL},
+    {XtNsizeMultipleLabelChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(size_multiple_label_child), XtRWidget, (XtPointer) NULL},
+    {XtNpreviewButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(preview_button_child), XtRWidget, (XtPointer) NULL},
+    {XtNsamplerButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(sampler_button_child), XtRWidget, (XtPointer) NULL},
+    {XtNseparatorChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(separator_child), XtRWidget, (XtPointer) NULL},
+    {XtNokButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(ok_button_child), XtRWidget, (XtPointer) NULL},
+    {XtNapplyButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(apply_button_child), XtRWidget, (XtPointer) NULL},
+    {XtNresetButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(reset_button_child), XtRWidget, (XtPointer) NULL},
+    {XtNcancelButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(cancel_button_child), XtRWidget, (XtPointer) NULL},
+    {XtNmultipleMasterButtonChild, XtCReadOnly, XtRWidget, sizeof(Widget),
+	Offset(multiple_master_button_child), XtRWidget, (XtPointer) NULL}
+};
+
+/* Forward declarations */
+
+static Boolean ChangeBlends(Widget w, String base_name, String blend_name, FSBBlendAction action, int *axis_values, float *axis_percents);
+static Boolean DownloadFontName(Widget w, String name);
+static Boolean MatchFontFace(Widget w, String old_face, String new_family, String *new_face);
+static Boolean SetValues(Widget old, Widget req, Widget new, ArgList args, Cardinal *num_args);
+static Boolean Verify(FontSelectionBoxWidget fsb, FSBValidateCallbackRec *cb, String afm, Boolean doIt);
+static String FindAFM(Widget w, String name);
+static String FindFontFile(Widget w, String name);
+static XtGeometryResult GeometryManager(Widget w, XtWidgetGeometry *desired, XtWidgetGeometry *allowed);
+static void ChangeManaged(Widget w);
+static void ClassInitialize(void);
+static void ClassPartInitialize(WidgetClass widget_class);
+static void Destroy(Widget widget);
+static void DisplayFontFamilies(FontSelectionBoxWidget fsb);
+static void FontFamilyFaceBlendToName(Widget w, String family, String face, String blend, String *font_name);
+static void FontFamilyFaceToName(Widget w, String family, String face, String *font_name);
+static void FontNameToFamilyFace(Widget w, String font_name, String *family, String *face);
+static void FontNameToFamilyFaceBlend(Widget w, String font_name, String *family, String *face, String *blend);
+static void FreeFontRec(FontRec *f);
+static void GetBlendInfo(Widget w, String name, int *num_axes_return, int *num_designs_return, String **axis_names_return, float **blend_positions_return, int **blend_map_count_return, int **blend_design_coords_return, float **blend_normalized_coords_return);
+static void GetBlendList(Widget w, String name, int *count_return, String **blend_return, String **font_name_return, float **axis_values_return);
+static void GetFaceList(Widget w, String family, int *count, String **face_list, String **font_list);
+static void GetFamilyList(Widget w, int *count, String **list);
+static void GetTextDimensions(Widget w, String text, String font, double size, double x, double y, float *dx, float *dy, float *left, float *right, float *top, float *bottom);
+static void Initialize(Widget request, Widget new, ArgList args, Cardinal *num_args);
+static void ReadBlends(FontSelectionBoxWidget fsb);
+static void RefreshFontList(Widget w);
+static void Resize(Widget widget);
+static void SetFontFamilyFace(Widget w, String family, String face, Bool family_multiple, Bool face_multiple);
+static void SetFontFamilyFaceBlend(Widget w, String family, String face, String blend, Bool family_multiple, Bool face_multiple);
+static void SetFontName(Widget w, String name, Bool name_multiple);
+static void SetFontSize(Widget w, double size, Bool size_multiple);
+static void SetUpCurrentSelections(FontSelectionBoxWidget fsb);
+static void UndefUnusedFonts(Widget w);
+static void WriteBlends(FontSelectionBoxWidget fsb);
+
+FontSelectionBoxClassRec fontSelectionBoxClassRec = {
+    /* Core class part */
+  {
+    /* superclass	     */	(WidgetClass) &xmManagerClassRec,
+    /* class_name	     */ "FontSelectionBox",
+    /* widget_size	     */ sizeof(FontSelectionBoxRec),
+    /* class_initialize      */ ClassInitialize,
+    /* class_part_initialize */ ClassPartInitialize,
+    /* class_inited          */	False,
+    /* initialize	     */	Initialize,
+    /* initialize_hook       */	NULL,
+    /* realize		     */	XtInheritRealize,
+    /* actions		     */	NULL,
+    /* num_actions	     */	0,
+    /* resources	     */	resources,
+    /* num_resources	     */	XtNumber(resources),
+    /* xrm_class	     */	NULLQUARK,
+    /* compress_motion	     */	True,
+    /* compress_exposure     */	XtExposeCompressMultiple,
+    /* compress_enterleave   */	True,
+    /* visible_interest	     */	False,
+    /* destroy		     */	Destroy,
+    /* resize		     */	Resize,
+    /* expose		     */	NULL,
+    /* set_values	     */	SetValues,
+    /* set_values_hook       */	NULL,			
+    /* set_values_almost     */	XtInheritSetValuesAlmost,  
+    /* get_values_hook       */	NULL,			
+    /* accept_focus	     */	NULL,
+    /* version		     */	XtVersion,
+    /* callback offsets      */	NULL,
+    /* tm_table              */	NULL,
+    /* query_geometry	     */	XtInheritQueryGeometry,
+    /* display_accelerator   */	NULL,
+    /* extension	     */	NULL,
+  },
+   /* Composite class part */
+  {
+    /* geometry_manager	     */	GeometryManager,
+    /* change_managed	     */	ChangeManaged,
+    /* insert_child	     */	XtInheritInsertChild,
+    /* delete_child	     */	XtInheritDeleteChild,
+    /* extension	     */	NULL,
+  },
+   /* Constraint class part */
+  {
+    /* resources	     */ NULL,
+    /* num_resources	     */ 0,
+    /* constraint_size	     */ 0,
+    /* initialize	     */ NULL,
+    /* destroy		     */ NULL,
+    /* set_values	     */ NULL,
+    /* extension	     */ NULL,
+  },
+   /* Manager class part */
+  {
+    /* translations	     */ XtInheritTranslations,
+    /* syn_resources	     */ NULL,
+    /* num_syn_resources     */ 0,
+    /* syn_constraint_resources */ NULL,
+    /* num_syn_constraint_resources */ 0,
+    /* parent_process	     */ XmInheritParentProcess,
+    /* extension	     */ NULL,
+  },
+   /* FontSelectionBox class part */
+  {
+    /* set_font_name	     */	SetFontName,
+    /* set_font_family_face  */	SetFontFamilyFace,
+    /* set_font_size	     */	SetFontSize,
+    /* refresh_font_list     */ RefreshFontList,
+    /* get_family_list	     */	GetFamilyList,
+    /* get_face_list	     */	GetFaceList,
+    /* undef_unused_fonts    */ UndefUnusedFonts,
+    /* download_font_name    */ DownloadFontName,
+    /* match_font_face	     */ MatchFontFace,
+    /* font_name_to_family_face */ FontNameToFamilyFace,
+    /* font_family_face_to_name */ FontFamilyFaceToName,
+    /* find_afm		     */ FindAFM,
+    /* find_font_file	     */ FindFontFile,
+    /* get_text_dimensions   */ GetTextDimensions,			
+    /* set_font_family_face_blend     */ SetFontFamilyFaceBlend,
+    /* font_name_to_family_face_blend */ FontNameToFamilyFaceBlend,
+    /* font_family_face_blend_to_name */ FontFamilyFaceBlendToName,
+    /* get_blend_list        */ GetBlendList,
+    /* get_blend_info        */ GetBlendInfo,
+    /* change_blends	     */ ChangeBlends,
+    /* extension	     */	NULL,
+  }
+};
+
+WidgetClass fontSelectionBoxWidgetClass =
+	(WidgetClass) &fontSelectionBoxClassRec;
+
+/* ARGSUSED */
+
+static Boolean CvtStringToFloatList(
+    Display *dpy,
+    XrmValuePtr args,
+    Cardinal *num_args,
+    XrmValuePtr from,
+    XrmValuePtr to,
+    XtPointer *data)
+{
+    register int i, count = 1;
+    register char *ch, *start = from->addr;
+    static float *list;
+    char save;
+
+    if (*num_args != 0) {	/* Check for correct number */
+	XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
+	       "cvtStringToFloatList", "wrongParameters",
+	       "XtToolkitError",
+	       "String to integer list conversion needs no extra arguments",
+	       (String *) NULL, (Cardinal *) NULL);
+    }
+
+    if (to->addr != NULL && to->size < sizeof(int *)) {
+	to->size = sizeof(int *);
+	return False;
+    }
+    if (start == NULL || *start == '\0') list = NULL;
+    else {
+	for (ch = start; *ch != '\0'; ch++) {    /* Count floats */
+	    if (!isdigit(*ch) && *ch != '.' && *ch != ',') {
+		XtDisplayStringConversionWarning(dpy, from->addr, "FloatList");
+		return False;
+	    }
+	    if (*ch == ',') count++;
+	}
+	list = (float *) XtCalloc(count+1, sizeof(float));
+
+	for (i = 0; i < count; i++) {
+	    for (ch = start; *ch != ',' && *ch != '\0'; ch++) {}
+	    save = *ch;
+	    *ch = '\0';
+	    list[i] = atof(start);
+	    *ch = save;
+	    start = ch + 1;
+	}
+    }
+    if (to->addr == NULL) to->addr = (caddr_t) &list;
+    else *(float **) to->addr = list;
+    to->size = sizeof(int *);
+    return True;
+}
+
+/* ARGSUSED */
+
+static void FloatListDestructor(
+    XtAppContext app,
+    XrmValuePtr to,
+    XtPointer converter_data,
+    XrmValuePtr args,
+    Cardinal *num_args)
+{
+    float *list = (float *) to->addr;
+
+    if (list == NULL) return;
+    XtFree((XtPointer) list);
+}
+
+XmString _FSBCreateSharedCS(String str, Widget w)
+{
+    XrmValue src, dst;
+    XmString result;
+
+    src.addr = str;
+    src.size = strlen(str);
+
+    dst.addr = (caddr_t) &result;
+    dst.size = sizeof(result);
+
+    if (XtConvertAndStore(w, XtRString, &src, XmRXmString, &dst)) {
+	return result;
+    } else return NULL;
+}
+ 
+static Boolean ScanFloat(char *src, float *f, char **past)
+{
+    char buf[20], *ch;
+    int countDecimals;
+
+    ch = buf;
+    countDecimals = 0;
+    while (*src == '.' || isdigit(*src)) {
+	if (*src == '.') {
+	    if (countDecimals) return False;
+	    else countDecimals++;
+	}
+	*ch++ = *src++;
+    }
+    if (ch == buf) return False;
+    *ch++ = '\0';
+    *f = atof(buf);
+    *past = src;
+    return True;
+}
+
+static Boolean ScanInt(char *src, int *i, char **past)
+{
+    char buf[20], *ch;
+
+    ch = buf;
+    while (isdigit(*src)) *ch++ = *src++;
+    if (ch == buf) return False;
+    *ch++ = '\0';
+    *i = atoi(buf);
+    *past = src;
+    return True;
+}
+
+static void ClassInitialize(void)
+{
+    /* Register a converter for string to int list */
+
+    XtSetTypeConverter(XtRString, XtRFloatList,
+	    CvtStringToFloatList, (XtConvertArgList) NULL, 0,
+	    XtCacheAll | XtCacheRefCount, FloatListDestructor);
+
+    CSempty = UnsharedCS("");
+}
+
+static void ClassPartInitialize(WidgetClass widget_class)
+{
+    register FontSelectionBoxWidgetClass wc =
+	    (FontSelectionBoxWidgetClass) widget_class;
+    FontSelectionBoxWidgetClass super =
+	    (FontSelectionBoxWidgetClass) wc->core_class.superclass;
+
+    if (wc->fsb_class.set_font_name == InheritSetFontName) {
+	wc->fsb_class.set_font_name = super->fsb_class.set_font_name;
+    }
+    if (wc->fsb_class.set_font_family_face == InheritSetFontFamilyFace) {
+	wc->fsb_class.set_font_family_face =
+		super->fsb_class.set_font_family_face;
+    }
+    if (wc->fsb_class.set_font_size == InheritSetFontSize) {
+	wc->fsb_class.set_font_size = super->fsb_class.set_font_size;
+    }
+    if (wc->fsb_class.refresh_font_list == InheritRefreshFontList) {
+	wc->fsb_class.refresh_font_list = super->fsb_class.refresh_font_list;
+    }
+    if (wc->fsb_class.get_family_list == InheritGetFamilyList) {
+	wc->fsb_class.get_family_list = super->fsb_class.get_family_list;
+    }
+    if (wc->fsb_class.get_face_list == InheritGetFaceList) {
+	wc->fsb_class.get_face_list = super->fsb_class.get_face_list;
+    }
+    if (wc->fsb_class.undef_unused_fonts == InheritUndefUnusedFonts) {
+	wc->fsb_class.undef_unused_fonts = super->fsb_class.undef_unused_fonts;
+    }
+    if (wc->fsb_class.download_font_name == InheritDownloadFontName) {
+	wc->fsb_class.download_font_name = super->fsb_class.download_font_name;
+    }
+    if (wc->fsb_class.match_font_face == InheritMatchFontFace) {
+	wc->fsb_class.match_font_face = super->fsb_class.match_font_face;
+    }
+    if (wc->fsb_class.font_name_to_family_face ==
+						InheritFontNameToFamilyFace) {
+	wc->fsb_class.font_name_to_family_face =
+		super->fsb_class.font_name_to_family_face;
+    }
+    if (wc->fsb_class.font_family_face_to_name ==
+						InheritFontFamilyFaceToName) {
+	wc->fsb_class.font_family_face_to_name =
+		super->fsb_class.font_family_face_to_name;
+    }
+    if (wc->fsb_class.find_afm == InheritFindAFM) {
+	wc->fsb_class.find_afm = super->fsb_class.find_afm;
+    }
+    if (wc->fsb_class.find_font_file == InheritFindFontFile) {
+	wc->fsb_class.find_font_file = super->fsb_class.find_font_file;
+    }
+    if (wc->fsb_class.get_text_dimensions == InheritGetTextDimensions) {
+	wc->fsb_class.get_text_dimensions =
+		super->fsb_class.get_text_dimensions;
+    }
+    if (wc->fsb_class.set_font_family_face_blend ==
+	InheritSetFontFamilyFaceBlend) {
+	wc->fsb_class.set_font_family_face_blend =
+		super->fsb_class.set_font_family_face_blend;
+    }
+    if (wc->fsb_class.font_name_to_family_face_blend ==
+	InheritFontNameToFamilyFaceBlend) {
+	wc->fsb_class.font_name_to_family_face_blend =
+		super->fsb_class.font_name_to_family_face_blend;
+    }
+    if (wc->fsb_class.font_family_face_blend_to_name ==
+	InheritFontFamilyFaceBlendToName) {
+	wc->fsb_class.font_family_face_blend_to_name =
+		super->fsb_class.font_family_face_blend_to_name;
+    }
+    if (wc->fsb_class.get_blend_list == InheritGetBlendList) {
+	wc->fsb_class.get_blend_list =
+		super->fsb_class.get_blend_list;
+    }
+    if (wc->fsb_class.get_blend_info == InheritGetBlendInfo) {
+	wc->fsb_class.get_blend_info =
+		super->fsb_class.get_blend_info;
+    }
+    if (wc->fsb_class.change_blends == InheritChangeBlends) {
+	wc->fsb_class.change_blends =
+		super->fsb_class.change_blends;
+    }
+}
+
+static String bugFamilies[] = {
+    "Berkeley", "CaslonFiveForty", "CaslonThree", "GaramondThree",
+    "Music", "TimesTen", NULL
+};
+
+static String fixedFamilies[] = {
+    "ITC Berkeley Oldstyle", "Caslon 540", "Caslon 3", "Garamond 3",
+    "Sonata", "Times 10", NULL
+};
+
+static String missingFoundries[] = {
+    "Berthold ", "ITC ", "Linotype ", NULL
+};
+
+static int missingFoundryLen[] = {
+    9, 4, 9, 0
+};
+
+/* I wish we didn't have to do this! */
+
+static void MungeFontNames(
+    String name, String family, String fullname, String weight,
+    String *familyReturn, String *fullnameReturn, String *faceReturn)
+{
+    register char *src, *dst, prev;
+    char buf[256];
+    int digits = 0;
+    int i, diff;
+    static Bool inited = False;
+    static String FetteFrakturDfr, LinotextDfr;
+
+    /* Don't make bugFamilies canonical; we'd have to make the initial
+       family canonical to do anything with it and there's no point in that */
+
+    if (!inited) {
+	for (i = 0; fixedFamilies[i] != NULL; i++) {
+	    fixedFamilies[i] = Canonical(fixedFamilies[i]);
+	}
+	FetteFrakturDfr = Canonical("FetteFraktur-Dfr");
+	LinotextDfr = Canonical("Linotext-Dfr");
+	inited = True;
+    }
+
+    /* Copy the fullname into buf, enforcing one space between words.
+       Eliminate leading digits and spaces, ignore asterisks, if the
+       full name ends with 5 digits strip them, and replace periods that
+       aren't followed by a space with a space.  If leading digits are
+       followed by " pt " skip that too. */
+
+    dst = buf;
+    prev = ' ';
+    src = fullname; 
+    while (isdigit(*src)) src++;
+    while (*src == ' ' || *src == '\t') src++;
+    if (strncmp(src, "pt ", 3) == 0) src += 3;
+    else if (strncmp(src, "pt. ", 4) == 0) src += 4;
+
+    while (*src != '\0') {
+	if (*src == '*') {
+	    src++;
+	    continue;
+	}
+
+	if (*src == '.') {
+	    if (*(src+1) != ' ') {
+		prev = *dst++ = ' ';
+	    } else prev = *dst++ = '.';
+	    src++;
+	    continue;
+	}
+
+	if (isdigit(*src)) digits++;
+	else digits = 0;
+
+	if (isupper(*src)) {
+	    if (prev != ' ' && (islower(*(src+1)) || islower(prev))) {
+		*dst++ = ' ';
+		prev = *dst++ = *src++;
+	    } else prev = *dst++ = *src++;
+
+	} else if (*src == ' ' || *src == '\t') {
+	    if (prev == ' ') {
+		src++;
+		continue;
+	    }
+	    prev = *dst++ = ' ';
+	    src++;
+
+	} else prev = *dst++ = *src++;
+    }
+
+    if (digits == 5) {
+	dst -= 5;
+    }
+    if (dst > buf && *(dst-1) == ' ') dst--;
+
+    *dst = '\0';
+
+    /* Stupid Fette Fraktur */
+
+    if (name == FetteFrakturDfr) {
+	strcat(buf, " Black Dfr");
+    } else if (name == LinotextDfr) {
+	strcat(buf, " Dfr");
+    }
+
+    if (strncmp(fullname, "pt ", 3) == 0) {
+	src = buf + 2;
+	while (*++src != '\0') *(src-3) = *src;
+	*(src-3) = '\0';
+    }
+    *fullnameReturn = XtNewString(buf);
+
+    /* From here on fullname should not be used */
+
+    /* Done with the full name; now onto the family */
+
+    for (i = 0; bugFamilies[i] != NULL; i++) {
+	diff = strcmp(family, bugFamilies[i]);
+	if (diff < 0) break;
+	if (diff == 0) {
+	    *familyReturn = fixedFamilies[i];
+	    goto FAMILY_DONE;
+	}
+    }
+
+    /* Copy the family into buf, enforcing one space between words */
+
+    dst = buf;
+    prev = ' ';
+    src = family; 
+
+    while (*src != '\0') {
+	if (isupper(*src)) {
+	    if (prev != ' ' && (islower(*(src+1)) || islower(prev))) {
+		*dst++ = ' ';
+		prev = *dst++ = *src++;
+	    } else prev = *dst++ = *src++;
+
+	} else if (*src == ' ' || *src == '\t') {
+	    if (prev == ' ') {
+		src++;
+		continue;
+	    }
+	    prev = *dst++ = ' ';
+	    src++;
+
+	} else prev = *dst++ = *src++;
+    }
+
+    if (dst > buf && *(dst-1) == ' ') dst--;
+    *dst = '\0';
+
+    /* Compensate for fonts with foundries in the full name but not the
+       family name by adding to the family name */
+ 
+    for (i = 0; missingFoundries[i] != NULL; i++) {
+	diff = strncmp(*fullnameReturn, missingFoundries[i],
+		       missingFoundryLen[i]);
+	if (diff > 0) continue;
+	if (diff == 0 && strncmp(buf, missingFoundries[i],
+		       missingFoundryLen[i] != 0)) {
+	    while (dst >= buf) {
+		*(dst+missingFoundryLen[i]) = *dst;
+		dst--;
+	    }
+	    strncpy(buf, missingFoundries[i], missingFoundryLen[i]);
+	}
+	break;
+    }
+
+    /* From here on dst no longer points to the end of the buffer */
+
+    /* Stupid Helvetica Rounded! */
+
+    if (strncmp(*fullnameReturn, "Helvetica Rounded ", 18) == 0) {
+	strcat(buf, " Rounded");
+    }
+
+    *familyReturn = Canonical(buf);
+
+    /* From here on family should not be used */
+
+FAMILY_DONE:
+
+    /* Now to find the face in all this */
+
+    src = *fullnameReturn;
+    dst = *familyReturn;
+    while (*dst == *src && *dst != '\0') {
+        src++;
+        dst++;
+    }
+    if (*src == ' ') src++;
+
+    if (*src != '\0') *faceReturn = Canonical(src);
+    else if (*weight != '\0') {
+	/* Handle Multiple Master fonts */
+	if (strcmp(weight, "All") == 0) *faceReturn = Canonical("Roman");
+	else {
+	    if (islower(weight[0])) weight[0] = toupper(weight[0]);
+	    *faceReturn = Canonical(weight);
+	}
+    } else *faceReturn = Canonical("Medium");
+}
+
+static String strip[] = {
+    "Adobe ", "Bauer ", "Berthold ", "ITC ", "Linotype ",
+    "New ", "Simoncini ", "Stempel ", NULL};
+
+static int striplen[] = {6, 6, 9, 4, 9, 4, 10, 8, 0};
+
+#define STEMPELINDEX 7
+
+static Boolean CreateSortKey(String family, String key)
+{
+    char newkey[256];
+    int len = strlen(family);
+    register int i, diff;
+
+    if (family[len-2] == 'P' && family[len-1] == 'i') {
+	key[0] = 'P';
+	key[1] = 'i';
+	key[2] = ' ';
+	strcpy(key+3, family);
+	key[len] = '\0';
+	return True;
+    }
+
+    for (i = 0; strip[i] != NULL; i++) {
+	diff = strncmp(family, strip[i], striplen[i]);
+	if (diff < 0) break;
+	if (diff == 0) {
+	    if (i == STEMPELINDEX) {
+		if (strcmp(family, "Stempel Schneidler") == 0) break;
+	    }
+	    strcpy(key, family + striplen[i]);
+	    key[len - striplen[i]] = ' ';
+	    strcpy(key + len - striplen[i] + 1, strip[i]);
+	    key[len] = '\0';
+	    if (CreateSortKey(key, newkey)) strcpy(key, newkey);
+	    return True;
+	}
+    }
+    strcpy(key, family);
+    return False;
+}
+
+#define SKIP_SPACE(buf) while (*buf == ' ' || *buf == '\t') buf++;
+
+static int CountAxes(char *buf)
+{
+    int count = 0;
+
+    while (*buf != '\0') {
+	SKIP_SPACE(buf)
+	if (*buf != '/') return 0;
+	buf++;
+	count++;
+	if (*buf == ' ' || *buf == '\t' || *buf == '\0') return 0;
+	while (*buf != ' ' && *buf != '\t' && *buf != '\0') buf++;
+    }
+    return count;
+}
+
+static Boolean ParseBlendPositions(
+    char *buf,
+    float *blendPos,
+    int *axes, int *designs)
+{
+    int i, j = 0;
+    float f;
+
+    *designs = 0;
+
+    while (*buf != '\0') {
+	SKIP_SPACE(buf)
+	if (*buf++ != '[') return True;
+
+	/* Now there should be *axes positive floats, separated by space */
+	SKIP_SPACE(buf)
+	for (i = 0; i < *axes; i++) {
+	    if (!ScanFloat(buf, &f, &buf)) return True;
+	    blendPos[j++] = f;
+	    SKIP_SPACE(buf)
+	}
+	if (*buf++ != ']') return True;
+	(*designs)++;
+    }
+    return False;
+}
+
+static Boolean ParseBlendMap(
+    char *buf,
+    int *breakCount,
+    int *blendBreak,
+    float *blendBreakValue,
+    int *axes)
+{
+    int i, j = 0;
+    int n;
+    float f;
+
+    /* OK.  What we expect to see here is *axes arrays.  Each one contains at
+       least 2 and no more than 12 subarrays, each of which contains 2 values,
+       an int and a float */
+
+    for (i = 0; i < *axes; i++) {
+
+	breakCount[i] = 0;
+
+	SKIP_SPACE(buf)
+	if (*buf++ != '[') return True;
+	SKIP_SPACE(buf)
+
+	while (*buf == '[') {
+	    buf++;
+	    SKIP_SPACE(buf)
+	    /* Now there should be an integer */
+	    if (!ScanInt(buf, &n, &buf)) return True;
+	    blendBreak[j] = n;
+
+	    SKIP_SPACE(buf)
+
+	    /* Now there should be a float */
+	    if (!ScanFloat(buf, &f, &buf)) return True;
+	    blendBreakValue[j++] = f;
+	    SKIP_SPACE(buf)
+
+	    /* Nothing more in the array */
+	    if (*buf++ != ']') return True;
+	    SKIP_SPACE(buf)
+
+	    breakCount[i]++;
+	    if (breakCount[i] == 12 && *buf != ']') return True;
+	}
+	if (*buf++ != ']') return True;
+    }
+    SKIP_SPACE(buf)
+    if (*buf != '\0') return True;
+    return False;
+}
+
+static Boolean ParseAxisNames(
+    int axes,
+    char *buf,
+    char *names[])
+{
+    int i = 0;
+
+    /* We expect to see axes names, each optionally preceded with a / and
+       separated by space */
+
+    while (*buf != '\0') {
+	SKIP_SPACE(buf)
+	if (*buf == '/') buf++;
+	names[i] = buf;
+	while (*buf !=  ' ' && *buf != '\t' && *buf != '\0') buf++;
+	if (buf != names[i]) i++;
+	if (*buf != '\0') *buf++ = '\0';
+	if (i >= axes) return True;
+    }
+    return False;
+}	
+#undef SKIP_SPACE
+
+static void GetPSFontInfo(
+    FontSelectionBoxWidget fsb,
+    char *name,
+    int *axes,
+    int *designs,
+    char *axisNames,
+    float *blendPos,
+    int *breakCount,
+    int *blendBreak,
+    float *blendBreakValue)
+{
+    int entries;
+    char **names, **data;
+
+    entries = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				  fsb->fsb.default_resource_path,
+				  "FontAxes", name,
+				  &names, &data);
+    if (entries < 1) {
+	*axes = 0;
+	return;
+    }
+    *axes = CountAxes(data[0]);
+    if (*axes == 0) return;
+    strcpy(axisNames, data[0]);
+
+    entries = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				  fsb->fsb.default_resource_path,
+				  "FontBlendMap", name,
+				  &names, &data);
+    if (entries < 1) {
+	*axes = 0;
+	return;
+    }
+    if (ParseBlendMap(data[0], breakCount,
+		      blendBreak, blendBreakValue, axes)) {
+	*axes = 0;
+	return;
+    }
+
+    entries = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				  fsb->fsb.default_resource_path,
+				  "FontBlendPositions", name,
+				  &names, &data);
+    if (entries < 1) {
+	*axes = 0;
+	return;
+    }
+    if (ParseBlendPositions(data[0], blendPos, axes, designs)) {
+	*axes = 0;
+	return;
+    }
+}
+
+static void AddFontRecord(
+    FontSelectionBoxWidget fsb,
+    int serverNum,
+    String name, String family, String fullname, String weight,
+    Boolean resident)
+{
+    FontFamilyRec *ff;
+    FontRec *f;
+    String familyReturn, fullnameReturn, faceReturn;
+    char axisNameBuf[256];
+    char *axisName[MAX_AXES];
+    int blendedFont, undefineIt, brokenFont;
+    int axes, designs, breakCount[MAX_AXES],
+	    blendBreak[12 * MAX_AXES];
+    float blendBreakValue[12 * MAX_AXES], blendPos[MAX_AXES * MAX_BLENDS];
+    char key[256];
+    int i, j, k, n;
+
+    name = Canonical(name);
+
+    /* First see if it's there already */
+
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == name) {
+		if (!f->resident && resident) f->resident = True;
+		return;
+	    }
+	}
+    }
+
+    /* We believe that names gotten from PS resource files have been
+       pre-munged, so no need to do it again */
+
+    if (resident) {
+	/* Have to get the info from the server */
+	_DPSFGetFontInfo(fsb->fsb.context, serverNum, fsb->fsb.old_server,
+			 family, fullname,
+			 weight, &blendedFont, &undefineIt, &brokenFont);
+
+	if (brokenFont) return;
+
+	/* Deal with fonts that don't have useful information */
+
+	if (family[0] == '\0') {
+	    if (fullname[0] == '\0') {
+		strcpy(family, name);
+		strcpy(fullname, name);
+	    } else strcpy(family, fullname);
+	} else if (fullname[0] == '\0') strcpy(fullname, family);
+
+	MungeFontNames(name, family, fullname, weight,
+		       &familyReturn, &fullnameReturn, &faceReturn);
+	if (blendedFont) {
+	    _DPSFGetBlendedFontInfo(fsb->fsb.context, serverNum,
+				    undefineIt, fsb->fsb.old_server,
+				    &axes, &designs, axisNameBuf,
+				    blendPos, breakCount, blendBreak,
+				    blendBreakValue, &brokenFont);
+	    if (brokenFont) axes = 0;
+	} else axes = 0;
+
+    } else {
+	familyReturn = Canonical(family);
+	fullnameReturn = XtNewString(fullname);
+	faceReturn = Canonical(weight);
+	GetPSFontInfo(fsb, name, &axes, &designs, axisNameBuf, blendPos,
+		      breakCount, blendBreak, blendBreakValue);
+    }
+
+    /* We didn't get an exact match, go for family match */
+
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	if (ff->family_name == familyReturn) break;
+    }
+
+    if (ff == NULL) {
+	ff = (FontFamilyRec *) XtMalloc(sizeof(FontFamilyRec));
+	ff->next = fsb->fsb.known_families;
+	ff->family_name = familyReturn;
+	ff->fonts = NULL;
+	ff->font_count = 0;
+	ff->blend_count = 0;
+	if (fsb->fsb.typographic_sort) {
+	    (void) CreateSortKey(familyReturn, key);
+	    ff->sort_key = XtNewString(key);
+	} else ff->sort_key = ff->family_name;
+	fsb->fsb.known_families = ff;
+	fsb->fsb.family_count++;
+    }
+
+    f = (FontRec *) XtMalloc(sizeof(FontRec));
+    f->next = ff->fonts;
+    f->font_name = name;
+    f->full_name = fullnameReturn;
+    f->resident = resident;
+    f->temp_resident = False;
+    f->in_font_creator = False;
+    f->pending_delete_next = NULL;
+    f->face_name = faceReturn;
+    f->CS_face_name = CS(f->face_name, (Widget) fsb);
+    f->blend_count = 0;
+
+    if (axes != 0 && ParseAxisNames(axes, axisNameBuf, axisName)) {
+	BlendDataRec *b;
+	
+	f->blend_data = b = XtNew(BlendDataRec);
+	b->num_axes = axes;
+	b->num_designs = designs;
+	k = 0;
+
+	for (i = 0; i < axes; i++) {
+	    b->internal_points[i] = breakCount[i] - 2;
+	    if (b->internal_points[i] <= 0) {
+		b->internal_break[i] = NULL;
+		b->internal_value[i] = NULL;
+		b->internal_points[i] = 0;
+	    } else {
+		b->internal_break[i] = (int *)
+			XtMalloc(b->internal_points[i] * sizeof(int));
+		b->internal_value[i] = (float *)
+			XtMalloc(b->internal_points[i] * sizeof(float));
+	    }
+
+	    n = 0;
+	    for (j = 0; j < breakCount[i]; j++) {
+		if (blendBreakValue[k] == 0.0) b->min[i] = blendBreak[k];
+		else if (blendBreakValue[k] == 1.0) b->max[i] = blendBreak[k];
+		else {
+		    b->internal_break[i][n] = blendBreak[k];
+		    b->internal_value[i][n++] = blendBreakValue[k];
+		}
+		k++;
+	    }
+	    b->name[i] = Canonical(axisName[i]);
+	}
+
+	b->design_positions =
+		(float *) XtMalloc(axes * designs * sizeof(float));
+	for (i = 0; i < axes * designs; i++) {
+	    b->design_positions[i] = blendPos[i];
+	}
+	b->blends = NULL;
+    } else f->blend_data = NULL;
+
+    ff->fonts = f;
+    ff->font_count++;
+}
+
+static void SortFontNames(FontFamilyRec *ff)
+{
+    FontRec *f, *highest, **prev, **highestPrev;
+    FontRec *newFontList = NULL;
+
+    while (ff->fonts != NULL) {
+	prev = highestPrev = &ff->fonts;
+	highest = ff->fonts;
+
+	for (f = ff->fonts->next; f != NULL; f = f->next) {
+	    prev = &(*prev)->next;
+	    if (strcmp(f->face_name, highest->face_name) > 0) {
+		highest = f;
+		highestPrev = prev;
+	    }
+	}
+
+	*highestPrev = highest->next;
+	highest->next = newFontList;
+	newFontList = highest;
+    }
+    ff->fonts = newFontList;
+}
+
+static void SortFontFamilies(FontSelectionBoxWidget fsb)
+{
+    FontFamilyRec *ff, *highest, **prev, **highestPrev;
+    FontFamilyRec *newFamilyList = NULL;
+
+    while (fsb->fsb.known_families != NULL) {
+	prev = highestPrev = &fsb->fsb.known_families;
+	highest = fsb->fsb.known_families;
+
+	for (ff = fsb->fsb.known_families->next; ff != NULL; ff = ff->next) {
+	    prev = &(*prev)->next;
+	    if (strcmp(ff->sort_key, highest->sort_key) > 0) {
+		highest = ff;
+		highestPrev = prev;
+	    }
+	}
+
+	*highestPrev = highest->next;
+	highest->next = newFamilyList;
+	newFamilyList = highest;
+	SortFontNames(highest);
+	if (fsb->fsb.typographic_sort) XtFree(highest->sort_key);
+	highest->sort_key = NULL;
+    }
+    fsb->fsb.known_families = newFamilyList;
+}
+
+static void AddFamily(
+    FontSelectionBoxWidget fsb,
+    char *family, char *fonts, char *weight, char *fullname, char *name)
+{
+    int j;
+    char *ch;
+
+    ch = fonts;
+    while (*ch != '\0') {
+	j = 0;
+	while (1) {
+            if (*ch == '\\' && (*(ch+1) == '\\' || *(ch+1) == ',')) {
+		ch++;
+		weight[j++] = *ch++;
+	    } else if (*ch == '\0' || *ch == ',') {
+		weight[j] = '\0';
+		break;
+	    } else weight[j++] = *ch++;
+	}
+	if (*ch == ',') {
+	    j = 0;
+	    ch++;
+	    while (1) {
+		if (*ch == '\\' && (*(ch+1) == '\\' || *(ch+1) == ',')) {
+		    ch++;
+		    name[j++] = *ch++;
+		} else if (*ch == '\0' || *ch == ',') {
+		    name[j] = '\0';
+		    break;
+	        } else name[j++] = *ch++;
+	    }
+	    strcpy(fullname, family);
+	    strcat(fullname, " ");
+	    strcat(fullname, weight);
+	    AddFontRecord(fsb, 0, name, family, fullname, weight, False);
+	    if (*ch == ',') ch++;
+	}
+    }
+}
+
+static void GetFontNames(FontSelectionBoxWidget fsb)
+{
+    int i;
+    char name[256], family[256], fullname[256], weight[256];
+    char *buffer, *ch, *start;
+    int fontCount, totalLength;
+    char **loadableFamilies = NULL, **loadableFamilyFonts = NULL;
+    
+    fsb->fsb.family_count = 0;
+
+    fontCount = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				    fsb->fsb.default_resource_path,
+				    PSResFontFamily, NULL,
+				    &loadableFamilies, &loadableFamilyFonts);
+    for (i = 0; i < fontCount; i++) {
+        AddFamily(fsb, loadableFamilies[i], loadableFamilyFonts[i],
+		  weight, fullname, name);
+    }
+
+    XtFree((XtPointer) loadableFamilies);
+    XtFree((XtPointer) loadableFamilyFonts);
+    FreePSResourceStorage(False);
+
+    if (fsb->fsb.get_server_fonts) {
+	_DPSFEnumFonts(fsb->fsb.context, &fontCount, &totalLength);
+
+	buffer = XtMalloc(totalLength);
+	_DPSFGetAllFontNames(fsb->fsb.context, fontCount, totalLength, buffer);
+	ch = start = buffer;
+	for (i = 0; i < fontCount; i++) {
+	    while (*ch != ' ') ch++;
+	    *ch = '\0';
+	    AddFontRecord(fsb, i, start, family, fullname, weight, True);
+	    start = ch+1;
+	}
+	XtFree(buffer);
+    }
+
+    _DPSFFreeFontInfo(fsb->fsb.context);
+    SortFontFamilies(fsb);
+    ReadBlends(fsb);
+}
+
+static void SensitizeReset(FontSelectionBoxWidget fsb)
+{
+    XtSetSensitive(fsb->fsb.reset_button_child, True);
+}
+
+static void DesensitizeReset(FontSelectionBoxWidget fsb)
+{
+    XtSetSensitive(fsb->fsb.reset_button_child, False);
+}
+
+static void ManageFamilyMultiple(FontSelectionBoxWidget fsb)
+{
+    XtManageChild(fsb->fsb.family_multiple_label_child);
+
+    XtVaSetValues(XtParent(fsb->fsb.family_scrolled_list_child),
+		  XmNtopWidget, fsb->fsb.family_multiple_label_child, NULL);
+}
+
+static void ManageFaceMultiple(FontSelectionBoxWidget fsb)
+{
+    XtManageChild(fsb->fsb.face_multiple_label_child);
+
+    XtVaSetValues(XtParent(fsb->fsb.face_scrolled_list_child),
+		  XmNtopWidget, fsb->fsb.face_multiple_label_child, NULL);
+}
+
+static void ManageMultipleMaster(FontSelectionBoxWidget fsb)
+{
+    XtManageChild(fsb->fsb.multiple_master_button_child);
+
+    XtVaSetValues(XtParent(fsb->fsb.face_scrolled_list_child),
+		  XmNbottomWidget, fsb->fsb.multiple_master_button_child,
+		  NULL);
+}
+
+static void ManageSizeMultiple(FontSelectionBoxWidget fsb)
+{
+    XtManageChild(fsb->fsb.size_multiple_label_child);
+}
+
+static void UnmanageFamilyMultiple(FontSelectionBoxWidget fsb)
+{
+    XtVaSetValues(XtParent(fsb->fsb.family_scrolled_list_child),
+		  XmNtopWidget, fsb->fsb.family_label_child, NULL);
+
+    XtUnmanageChild(fsb->fsb.family_multiple_label_child);
+}
+
+static void UnmanageFaceMultiple(FontSelectionBoxWidget fsb)
+{
+    XtVaSetValues(XtParent(fsb->fsb.face_scrolled_list_child),
+		  XmNtopWidget, fsb->fsb.face_label_child, NULL);
+
+    XtUnmanageChild(fsb->fsb.face_multiple_label_child);
+}
+
+static void UnmanageMultipleMaster(FontSelectionBoxWidget fsb)
+{
+    XtUnmanageChild(fsb->fsb.multiple_master_button_child);
+
+    XtVaSetValues(XtParent(fsb->fsb.face_scrolled_list_child),
+		  XmNbottomWidget, fsb->fsb.size_text_field_child, NULL);
+}
+
+static void UnmanageSizeMultiple(FontSelectionBoxWidget fsb)
+{
+    XtUnmanageChild(fsb->fsb.size_multiple_label_child);
+}
+
+/* Callbacks for subwidgets */
+
+static Boolean DownloadFont(
+    FontSelectionBoxWidget fsb,
+    String name,
+    DPSContext ctxt,
+    Boolean make_shared)
+{
+    int count;
+    char **names, **files;
+    FILE *f;
+#define BUFLEN 256
+    char buf[BUFLEN];
+    static char eobuf[] = "\n$Adobe$DPS$Lib$Dict /downloadSuccess true put\n\
+stop\n\
+Magic end of data line )))))))))) 99#2 2#99 <xyz> // 7gsad,32h4ghNmndFgj2\n";
+    int currentShared, ok;
+
+    /* Assume context is correct */
+
+    count = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				fsb->fsb.default_resource_path,
+				PSResFontOutline, name,
+				&names, &files);
+    if (count == 0) return False;
+
+    f = fopen(files[0], "r");
+    if (f == NULL) return False;
+
+    /* A bug in 1006.9 and earlier servers prevents the more robust
+       downloading method from working reliably. */
+
+    if (fsb->fsb.old_server) {
+	DPSPrintf(ctxt, "\ncurrentshared %s setshared\n",
+		  (make_shared ? "true" : "false"));
+	while (fgets(buf, BUFLEN, f) != NULL) {
+	    DPSWritePostScript(ctxt, buf, strlen(buf));
+	}
+	DPSWritePostScript(ctxt, "\nsetshared\n", 11);
+	ok = True;
+
+    } else {
+	_DPSFPrepareToDownload(ctxt, make_shared, &currentShared);
+	DPSWriteData(ctxt, "\nexec\n", 6);
+
+	while (fgets(buf, BUFLEN, f) != NULL) {
+	    DPSWriteData(ctxt, buf, strlen(buf));
+	}
+
+	/* This marks the end of the data stream */
+	DPSWriteData(ctxt, eobuf, strlen(eobuf));
+
+	/* Check the results of the download by getting the error status */
+	_DPSFFinishDownload(ctxt, currentShared, &ok);
+    }
+
+    fclose (f);
+    free(names);
+    free(files);
+    return ok;
+
+#undef BUFLEN
+}
+
+static void UndefSomeUnusedFonts(
+    FontSelectionBoxWidget fsb,
+    Boolean all)
+{
+    FontRec *f, *nextf, **start;
+    int i;
+
+    if (!all
+     && (Cardinal)fsb->fsb.pending_delete_count < fsb->fsb.max_pending_deletes) {
+	return;
+    }
+
+    if (all) start = &fsb->fsb.pending_delete_font;
+    else {
+	/* Skip to the end of the ones we're keeping */
+	f = fsb->fsb.pending_delete_font;
+	for (i = 1; f != NULL && (Cardinal)i < fsb->fsb.max_pending_deletes; i++) {
+	    f = f->pending_delete_next;
+	}
+	if (f == NULL) return;
+	start = &f->pending_delete_next;
+    }
+
+    for (f = *start; f != NULL; f = nextf) {
+	nextf = f->pending_delete_next;
+	if (f == fsb->fsb.currently_previewed) {
+	    start = &f->pending_delete_next;
+	    continue;
+	}
+	*start = nextf;
+	if (!f->resident && !f->in_font_creator) {
+	    _DPSFUndefineFont(fsb->fsb.context, f->font_name,
+			      fsb->fsb.old_server);
+	}
+	f->temp_resident = False;
+	fsb->fsb.pending_delete_count--;	    
+	f->pending_delete_next = NULL;
+    }
+}
+
+static void UndefUnusedFonts(Widget w)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+
+    UndefSomeUnusedFonts(fsb, True);
+}
+
+Boolean _FSBDownloadFontIfNecessary(
+    FontRec *f,
+    FontSelectionBoxWidget fsb)
+{
+    Boolean shared;
+
+    if (!f->resident && !f->temp_resident) {
+
+	shared = fsb->fsb.make_fonts_shared && !fsb->fsb.undef_unused_fonts;
+	if (!fsb->fsb.get_server_fonts) {
+	    int resident;
+	    /* This font might already be there, so check before downloading */
+	    _DPSFIsFontResident(fsb->fsb.context, f->font_name, &resident);
+	    if (resident) {
+		f->resident = True;
+		return True;
+	    }
+	}
+	if (!DownloadFont(fsb, f->font_name, fsb->fsb.context, shared)) {
+	    _FSBFlushFont(fsb, f);
+	    return False;
+	}
+	if (shared) f->resident = True;
+	else f->temp_resident = True;
+
+	if (f->pending_delete_next == NULL && fsb->fsb.undef_unused_fonts) {
+	    f->pending_delete_next = fsb->fsb.pending_delete_font;
+	    fsb->fsb.pending_delete_font = f;
+	    fsb->fsb.pending_delete_count++;
+	    UndefSomeUnusedFonts(fsb, False);
+	}
+    }
+    return True;
+}
+
+static void DoPreview(
+    FontSelectionBoxWidget fsb,
+    Boolean override)
+{
+    int i, n;
+    int *selectList, selectCount;
+    float size;
+    FontFamilyRec *ff = fsb->fsb.known_families;
+    FontRec *f;
+    BlendRec *b;
+    char *chSize, *fontName;
+    Dimension height;
+    Cardinal depth;
+    int bogusFont;
+
+    if (!XtIsRealized(fsb)) return;
+
+    XtVaGetValues(fsb->fsb.preview_child, XmNheight, &height,
+		  XmNdepth, &depth, NULL);
+
+    if (fsb->fsb.gstate == 0) {
+	XDPSSetContextParameters(fsb->fsb.context, XtScreen(fsb), depth,
+				 XtWindow(fsb->fsb.preview_child), height,
+				 (XDPSStandardColormap *) NULL,
+				 (XDPSStandardColormap *) NULL,
+				 XDPSContextScreenDepth | XDPSContextDrawable |
+				 XDPSContextRGBMap | XDPSContextGrayMap);
+	XDPSCaptureContextGState(fsb->fsb.context, &fsb->fsb.gstate);
+    } else XDPSSetContextGState(fsb->fsb.context, fsb->fsb.gstate);
+
+    _DPSFClearWindow(fsb->fsb.context);
+
+    if (override) {
+	if (fsb->fsb.current_family_multiple ||
+	    fsb->fsb.current_face_multiple ||
+	    fsb->fsb.current_size_multiple) return;
+	f = fsb->fsb.currently_previewed;
+	size = fsb->fsb.currently_previewed_size;
+	b = fsb->fsb.currently_previewed_blend;
+    }
+
+    if (!override || f == NULL || size == 0.0) {
+	if (!XmListGetSelectedPos(fsb->fsb.family_scrolled_list_child,
+				  &selectList, &selectCount)) return;
+	if (selectCount == 0 ||
+	    *selectList < 1 || *selectList > fsb->fsb.family_count) return;
+
+	for (i = 1; i < *selectList; i++) ff = ff->next;
+    
+	XtFree((XtPointer) selectList);
+
+	if (!XmListGetSelectedPos(fsb->fsb.face_scrolled_list_child,
+				  &selectList, &selectCount)) return;
+	if (selectCount == 0 ||
+	    *selectList < 1 ||
+	    *selectList > ff->font_count + ff->blend_count) return;
+
+	f = ff->fonts;
+	n = 0;
+	while (1) {
+	    n += f->blend_count + 1;
+	    if (n >= *selectList) {
+		n -= f->blend_count;
+		if (n == *selectList) b = NULL;
+		else for (b = f->blend_data->blends;
+			  n < *selectList - 1; b = b->next) n++;
+		break;
+	    }
+	    f = f->next;
+	}
+    
+	XtFree((XtPointer) selectList);
+
+	XtVaGetValues(fsb->fsb.size_text_field_child,
+		      XmNvalue, &chSize, NULL); 
+
+	if (chSize == NULL || *chSize == '\0') return;
+	size = atof(chSize);
+    }
+
+    if (size <= 0.0) return;
+
+    fsb->fsb.currently_previewed = f;
+    fsb->fsb.currently_previewed_blend = b;
+    fsb->fsb.currently_previewed_size = size;
+
+    if (!_FSBDownloadFontIfNecessary(f, fsb)) return;
+
+    if (b == NULL) fontName = f->font_name;
+    else fontName = b->font_name;
+
+    if (fsb->fsb.preview_string == NULL) {
+	_DPSFPreviewString(fsb->fsb.context, fontName, size,
+			   f->full_name, height, &bogusFont);
+    } else _DPSFPreviewString(fsb->fsb.context, fontName, size,
+			      fsb->fsb.preview_string, height, &bogusFont);
+    if (bogusFont) {
+	_FSBBogusFont(fsb, f);
+    }
+}
+
+static void DoValueChangedCallback(FontSelectionBoxWidget fsb)
+{
+    String afm = NULL;
+    FSBValidateCallbackRec cb;
+
+    if (fsb->fsb.get_afm) {
+	if (fsb->fsb.currently_selected_face == NULL) afm = NULL;
+	else afm = FindAFM((Widget) fsb,
+			   fsb->fsb.currently_selected_face->font_name);
+    }
+
+    (void) Verify(fsb, &cb, afm, False);
+    cb.reason = FSBValueChanged;
+
+    XtCallCallbackList((Widget) fsb, fsb->fsb.value_changed_callback, &cb);
+}
+
+static void ValueChanged(FontSelectionBoxWidget fsb)
+{
+    if (fsb->fsb.auto_preview) DoPreview(fsb, False);
+    DoValueChangedCallback(fsb);
+}
+
+/* ARGSUSED */
+
+static void PreviewText(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+    XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) callData;
+
+    if (!fsb->fsb.preview_fixed) {
+	XSetWindowAttributes att;
+	att.bit_gravity = ForgetGravity;
+	XChangeWindowAttributes(XtDisplay(fsb),
+				XtWindow(fsb->fsb.preview_child),
+				CWBitGravity, &att);
+	fsb->fsb.preview_fixed = True;
+    }
+
+    if (cb != NULL && cb->event->type == Expose &&
+	cb->event->xexpose.count != 0) return;
+
+    DoPreview(fsb, True);
+}
+
+/* ARGSUSED */
+
+static void PreviewCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    DoPreview(fsb, False);
+}
+
+/* ARGSUSED */
+
+static void DismissSamplerCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    fsb->fsb.show_sampler = False;
+}
+
+static void ShowSampler(FontSelectionBoxWidget fsb)
+{
+    int i;
+    Arg args[2];
+    Widget s;
+
+    if (fsb->fsb.sampler == NULL) {
+	FSBCreateSamplerCallbackRec cs;
+
+	cs.sampler_shell = NULL;
+
+	XtCallCallbackList((Widget) fsb, fsb->fsb.create_sampler_callback,
+			   (XtPointer) &cs);
+
+	if (cs.sampler_shell == NULL || cs.sampler == NULL) {
+	    fsb->fsb.sampler =
+		    XtCreatePopupShell("samplerShell",
+				       transientShellWidgetClass,	
+				       (Widget) fsb, (ArgList) NULL, 0);
+	    i = 0;
+	    XtSetArg(args[i], XtNfontSelectionBox, fsb);		i++;
+	    s = XtCreateManagedWidget("sampler", fontSamplerWidgetClass,
+				      fsb->fsb.sampler, args, i);
+	    XtAddCallback(s, XtNdismissCallback,
+			  DismissSamplerCallback, (XtPointer) fsb);
+	} else {
+	    fsb->fsb.sampler = cs.sampler_shell;
+	    XtAddCallback(cs.sampler, XtNdismissCallback,
+			  DismissSamplerCallback, (XtPointer) fsb);
+	}
+    }
+    XtPopup(fsb->fsb.sampler, XtGrabNone);
+    XRaiseWindow(XtDisplay(fsb->fsb.sampler), XtWindow(fsb->fsb.sampler));
+    fsb->fsb.show_sampler = True;
+}
+
+static void ShowCreator(FontSelectionBoxWidget fsb)
+{
+    int i;
+    Arg args[2];
+    FSBCreateCreatorCallbackRec cc;
+
+    if (fsb->fsb.creator == NULL) {
+
+	cc.creator_shell = NULL;
+
+	XtCallCallbackList((Widget) fsb, fsb->fsb.create_creator_callback,
+			   (XtPointer) &cc);
+
+	if (cc.creator_shell == NULL || cc.creator == NULL) {
+	    cc.creator_shell =
+		    XtCreatePopupShell("creatorShell",
+				       transientShellWidgetClass,	
+				       (Widget) fsb, (ArgList) NULL, 0);
+	    i = 0;
+	    XtSetArg(args[i], XtNfontSelectionBox, fsb);		i++;
+	    cc.creator =
+		    XtCreateManagedWidget("creator", fontCreatorWidgetClass,
+					  cc.creator_shell, args, i);
+	}
+	fsb->fsb.creator_shell = cc.creator_shell;
+	fsb->fsb.creator = cc.creator;
+    }
+
+    XtPopup(fsb->fsb.creator_shell, XtGrabNone);
+    XRaiseWindow(XtDisplay(fsb->fsb.creator_shell),
+		 XtWindow(fsb->fsb.creator_shell)); 
+
+    _FSBSetCreatorFamily(fsb->fsb.creator, fsb->fsb.currently_selected_family);
+}
+
+/* ARGSUSED */
+
+static void ShowCreatorCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    ShowCreator(fsb);
+}
+
+/* ARGSUSED */
+
+static void ShowSamplerCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    ShowSampler(fsb);
+}
+
+/* ARGSUSED */
+
+static void PreviewDoubleClick(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    DoPreview(fsb, False);
+}
+
+/* ARGSUSED */
+
+static void ResizePreview(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    Dimension height;
+    Cardinal depth;
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    if (!XtIsRealized(widget) || fsb->fsb.gstate == 0) return;
+
+    XtVaGetValues(widget, XmNheight, &height, XmNdepth, &depth, NULL);
+
+    XDPSSetContextGState(fsb->fsb.context, fsb->fsb.gstate);
+
+    XDPSSetContextParameters(fsb->fsb.context, XtScreen(widget), depth,
+			     XtWindow(widget), height,
+			     (XDPSStandardColormap *) NULL,
+			     (XDPSStandardColormap *) NULL,
+			     XDPSContextScreenDepth | XDPSContextDrawable);
+
+    _DPSFReclip(fsb->fsb.context);
+
+    XDPSUpdateContextGState(fsb->fsb.context, fsb->fsb.gstate);
+}
+
+static String FindAFMRecursive(
+    Widget w,
+    String name,
+    Boolean recur)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    int count;
+    char **names, **files;
+    String ret, ch;
+
+    if (name == NULL) return NULL;
+
+    count = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				fsb->fsb.default_resource_path,
+				PSResFontAFM,
+				name,
+				&names, &files);
+    
+    if (count == 0 && recur) {
+	for (ch = name; *ch != '_' && *ch != '\0'; ch++) {}
+	if (*ch == '\0') return NULL;
+	*ch = '\0';
+	ret = FindAFMRecursive(w, name, False);
+	*ch = '_';
+	return ret;
+    }
+
+    if (count == 0) return NULL;
+    ret = files[0];
+    free(names);
+    free(files);
+    return ret;
+}
+
+static String FindAFM(Widget w, String name)
+{
+    return FindAFMRecursive(w, name, True);
+}
+
+static String FindFontFileRecursive(
+    Widget w,
+    String name,
+    Boolean recur)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    int count;
+    char **names, **files;
+    String ret, ch;
+
+    if (name == NULL) return NULL;
+
+    count = ListPSResourceFiles(fsb->fsb.resource_path_override,
+				fsb->fsb.default_resource_path,
+				PSResFontOutline,
+				name,
+				&names, &files);
+    
+    if (count == 0 && recur) {
+	for (ch = name; *ch != '_' && *ch != '\0'; ch++) {}
+	if (*ch == '\0') return NULL;
+	*ch = '\0';
+	ret = FindFontFileRecursive(w, name, False);
+	*ch = '_';
+	return ret;
+    }
+
+    if (count == 0) return NULL;
+    ret = files[0];
+    free(names);
+    free(files);
+    return ret;
+}
+
+static String FindFontFile(Widget w, String name)
+{
+    return FindFontFileRecursive(w, name, True);
+}
+
+static Boolean Verify(
+    FontSelectionBoxWidget fsb,
+    FSBValidateCallbackRec *cb,
+    String afm,
+    Boolean doIt)
+{
+    char *chSize;
+    int i;
+
+    if (fsb->fsb.current_family_multiple) {
+	cb->family = NULL;
+	cb->family_selection = FSBMultiple;
+    } else if (fsb->fsb.currently_selected_family == NULL) {
+	cb->family = NULL;
+	cb->family_selection = FSBNone;
+    } else {
+	cb->family = fsb->fsb.currently_selected_family->family_name;
+	cb->family_selection = FSBOne;
+    }
+
+    if (fsb->fsb.current_face_multiple) {
+	cb->face = NULL;
+	cb->face_selection = FSBMultiple;
+    } else if (fsb->fsb.currently_selected_face == NULL) {
+	cb->face = NULL;
+	cb->face_selection = FSBNone;
+    } else {
+	cb->face = fsb->fsb.currently_selected_face->face_name;
+	cb->face_selection = FSBOne;
+    }
+	
+    if (cb->family_selection == FSBMultiple ||
+	cb->face_selection == FSBMultiple) {
+	cb->name = NULL;
+	cb->name_selection = FSBMultiple;
+    } else if (fsb->fsb.currently_selected_face == NULL) {
+	cb->name = NULL;
+	cb->name_selection = FSBNone;
+    } else {
+	if (fsb->fsb.currently_selected_blend != NULL) {
+	    cb->name = fsb->fsb.currently_selected_blend->font_name;
+	} else cb->name = fsb->fsb.currently_selected_face->font_name;
+	cb->name_selection = FSBOne;
+    }
+
+    if (fsb->fsb.current_size_multiple) {
+	cb->size = 0.0;
+	cb->size_selection = FSBMultiple;
+    } else {
+	XtVaGetValues(fsb->fsb.size_text_field_child, XmNvalue, &chSize, NULL);
+
+	if (chSize == NULL || *chSize == '\0') {
+	    cb->size = 0.0;
+	    cb->size_selection = FSBNone;
+	} else {
+	    cb->size = atof(chSize);
+	    cb->size_selection = FSBOne;
+	}
+    }
+
+    cb->afm_filename = afm;
+    cb->afm_present = (afm != NULL);
+    cb->doit = True;
+
+    if (fsb->fsb.currently_selected_blend == NULL) {
+	cb->blend = cb->base_name = NULL;
+	for (i = 0; i < MAX_AXES; i++) cb->axis_percent[i] = 0.0;
+    } else {
+	cb->blend = fsb->fsb.currently_selected_blend->blend_name;
+	cb->base_name = fsb->fsb.currently_selected_face->font_name;
+	for (i = 0; i < MAX_AXES; i++) {
+	    cb->axis_percent[i] = fsb->fsb.currently_selected_blend->data[i];
+	}
+    }
+
+    if (doIt) XtCallCallbackList((Widget) fsb, fsb->fsb.validate_callback, cb);
+    return cb->doit;
+}
+
+static Boolean VerifyAndCallback(
+    FontSelectionBoxWidget fsb,
+    FSBCallbackReason reason,
+    XtCallbackList callback)
+{
+    String afm = NULL;
+    FSBValidateCallbackRec cb;
+    FontRec *fsave, *face;
+
+    if (fsb->fsb.get_afm) {
+	if (fsb->fsb.currently_selected_face == NULL) afm = NULL;
+	else afm = FindAFM((Widget) fsb,
+			   fsb->fsb.currently_selected_face->font_name);
+    }
+
+    DoPreview(fsb, False);
+
+    cb.reason = reason;
+    if (!Verify(fsb, &cb, afm, True)) return False;
+
+    fsb->fsb.font_family_multiple = fsb->fsb.current_family_multiple;
+    if (!fsb->fsb.font_family_multiple &&
+	fsb->fsb.currently_selected_family != NULL) {
+	fsb->fsb.font_family =
+		fsb->fsb.currently_selected_family->family_name;
+    } else fsb->fsb.font_family = NULL;
+
+    fsb->fsb.font_face_multiple = fsb->fsb.current_face_multiple;
+    if (!fsb->fsb.font_face_multiple &&
+	fsb->fsb.currently_selected_face != NULL) {
+	fsb->fsb.font_face = fsb->fsb.currently_selected_face->face_name;
+    } else fsb->fsb.font_face = NULL;
+
+    fsb->fsb.font_name_multiple =
+	    fsb->fsb.font_family_multiple || fsb->fsb.font_face_multiple;
+    if (!fsb->fsb.font_name_multiple &&
+	fsb->fsb.currently_selected_face != NULL) {
+	fsb->fsb.font_name = fsb->fsb.currently_selected_face->font_name;
+    } else fsb->fsb.font_name = NULL;
+
+    fsb->fsb.font_size_multiple = fsb->fsb.current_size_multiple;
+    if (!fsb->fsb.font_size_multiple) {
+	fsb->fsb.font_size = cb.size;
+    }
+
+    if (fsb->fsb.currently_selected_blend != NULL) {
+	fsb->fsb.font_blend = fsb->fsb.currently_selected_blend->blend_name;
+    } else fsb->fsb.font_blend = NULL;
+
+    if (fsb->fsb.undef_unused_fonts) {
+	fsave = fsb->fsb.currently_previewed;
+	if (fsb->fsb.make_fonts_shared) {
+	    fsb->fsb.currently_previewed = NULL;
+	}
+	UndefUnusedFonts((Widget)fsb);
+	fsb->fsb.currently_previewed = fsave;
+	face = fsb->fsb.currently_selected_face;
+	if (face != NULL && !face->resident) {
+	    face->resident = True;
+	    if (fsb->fsb.make_fonts_shared) {
+		(void) DownloadFont(fsb, face->font_name,
+				    fsb->fsb.context, True);
+		/* If making it shared, be sure to synchronize with
+		   the caller who might be using a different context */
+		DPSWaitContext(fsb->fsb.context);
+	    }
+	}
+    }
+
+    XtCallCallbackList((Widget) fsb, callback, &cb);
+    return True;
+}
+
+/* ARGSUSED */
+
+static void OKCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    if (!VerifyAndCallback(fsb, FSBOK, fsb->fsb.ok_callback)) return;
+    if (XtIsShell(XtParent(fsb))) XtPopdown(XtParent(fsb));
+    WriteBlends(fsb);
+    DesensitizeReset(fsb);
+    if (fsb->fsb.show_sampler) XtPopdown(fsb->fsb.sampler);
+}
+
+/* ARGSUSED */
+
+static void ApplyCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    (void) VerifyAndCallback(fsb, FSBApply, fsb->fsb.apply_callback);
+    WriteBlends(fsb);
+    DesensitizeReset(fsb);
+}
+
+static void ResetFSB(
+    FontSelectionBoxWidget fsb,
+    FSBCallbackReason reason)
+{
+    FSBCallbackRec cb;
+    int i;
+
+    fsb->fsb.currently_previewed = NULL;
+    fsb->fsb.currently_previewed_size = fsb->fsb.currently_selected_size = 0.0;
+    SetUpCurrentSelections(fsb);
+    if (fsb->fsb.undef_unused_fonts) UndefUnusedFonts((Widget)fsb);
+
+    cb.reason = reason;
+    if (fsb->fsb.font_family_multiple) {
+	cb.family = NULL;
+	cb.family_selection = FSBMultiple;
+    } else if (fsb->fsb.font_family == NULL) {
+	cb.family = NULL;
+	cb.family_selection = FSBNone;
+    } else {
+	cb.family = fsb->fsb.font_family;
+	cb.family_selection = FSBOne;
+    }
+
+    if (fsb->fsb.font_face_multiple) {
+	cb.face = NULL;
+	cb.face_selection = FSBMultiple;
+    } else if (fsb->fsb.font_face == NULL) {
+	cb.face = NULL;
+	cb.face_selection = FSBNone;
+    } else {
+	cb.face = fsb->fsb.font_face;
+	cb.face_selection = FSBOne;
+    }
+	
+    if (cb.family_selection == FSBMultiple ||
+	cb.face_selection == FSBMultiple) {
+	cb.name = NULL;
+	cb.name_selection = FSBMultiple;
+    } else if (fsb->fsb.font_face == NULL) {
+	cb.name = NULL;
+	cb.name_selection = FSBNone;
+    } else {
+	cb.name = fsb->fsb.font_name;
+	cb.name_selection = FSBOne;
+    }
+
+    if (fsb->fsb.font_size_multiple) {
+	cb.size = 0.0;
+	cb.size_selection = FSBMultiple;
+    } else {
+	cb.size = fsb->fsb.font_size;
+	cb.size_selection = FSBOne;
+    }
+
+    cb.afm_filename = NULL;
+    cb.afm_present = False;
+
+    cb.blend = fsb->fsb.font_blend;
+    if (cb.blend == NULL || fsb->fsb.currently_selected_blend == NULL) {
+	cb.base_name = NULL;
+	for (i = 0; i < MAX_AXES; i++) cb.axis_percent[i] = 0;
+    } else {
+	cb.base_name = fsb->fsb.currently_selected_face->font_name;
+	for (i = 0; i < MAX_AXES; i++) {
+	    cb.axis_percent[i] = fsb->fsb.currently_selected_blend->data[i];
+	}
+    }
+
+    if (reason == FSBReset) {
+	XtCallCallbackList((Widget) fsb, fsb->fsb.reset_callback, &cb);
+    } else XtCallCallbackList((Widget) fsb, fsb->fsb.cancel_callback, &cb);
+}
+
+/* ARGSUSED */
+
+static void ResetCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    ResetFSB(fsb, FSBReset);
+    DesensitizeReset(fsb);
+}
+
+/* ARGSUSED */
+
+static void CancelCallback(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    ResetFSB(fsb, FSBCancel);
+    if (XtIsShell(XtParent(fsb))) XtPopdown(XtParent(fsb));
+    DesensitizeReset(fsb);
+    if (fsb->fsb.show_sampler) XtPopdown(fsb->fsb.sampler);
+}
+
+/* There's a problem; sometimes the change has already been made in the field,
+   and sometimes it hasn't.  The times when it has seem to correspond to
+   making changes with the size option menu, so we use this disgusting
+   global flag to notice when this happens.  We also use this to tell whether
+   or not the change is coming from internal to the widget or as a result
+   of user interaction.  */
+
+static Boolean changingSize = False;
+
+/* ARGSUSED */
+
+static void SizeSelect(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    String value;
+    Widget option;
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+    char *ch;
+
+    XtVaGetValues(widget, XmNvalue, &value, NULL);
+
+    if (value == NULL) option = fsb->fsb.other_size;
+    else {
+	if (value[0] != '\0' && fsb->fsb.current_size_multiple) {
+	    fsb->fsb.current_size_multiple = False;
+	    UnmanageSizeMultiple(fsb);
+	}
+	for (ch = value; *ch != '\0'; ch++) if (*ch == '.') *ch = '-';
+
+	option = XtNameToWidget(fsb->fsb.size_menu, value);
+	if (option == NULL) option = fsb->fsb.other_size;
+    }
+
+    XtVaSetValues(fsb->fsb.size_option_menu_child,
+		  XmNmenuHistory, option, NULL);
+
+    if (value != NULL && value[0] != '\0') {
+	fsb->fsb.currently_selected_size = atof(value);
+    } else fsb->fsb.currently_selected_size = 0.0;
+
+    if (!changingSize) SensitizeReset(fsb);
+    fsb->fsb.current_size_multiple = False;
+}
+
+/* ARGSUSED */
+
+static void TextVerify(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    int i;
+    XmTextVerifyPtr v = (XmTextVerifyPtr) callData;
+    char ch, *cp;
+    int decimalPoints = 0;
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    if (changingSize) return;	/* We know what we're doing; allow it */
+
+    /* Should probably look at format field, but seems to contain garbage */
+
+    if (v->text->length == 0) return;
+
+    if (v->text->length == 1) {
+	ch = v->text->ptr[0];
+	if (ch == 'p' || ch == 'P') {
+	    XtCallCallbacks(fsb->fsb.preview_button_child,
+			    XmNactivateCallback, NULL);
+	    v->doit = False;
+	    return;
+	}
+    }
+	
+    for (i = 0; i < v->text->length; i++) {
+	ch = v->text->ptr[i];
+	if (ch == '.') decimalPoints++;
+	else if (!isdigit(ch)) {
+	    v->doit = False;
+	    return;
+	}
+    }
+
+    if (decimalPoints > 1) {
+	v->doit = False;
+	return;
+    }
+
+    XtVaGetValues(widget, XmNvalue, &cp, NULL);
+
+    for (/**/; *cp != '\0'; cp++) {
+	if (*cp == '.') decimalPoints++;
+    }
+
+    if (decimalPoints > 1) v->doit = False;
+}
+
+/* ARGSUSED */
+
+static void SetSize(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    char buf[20];
+    char *ch;
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+
+    if (fsb->fsb.current_size_multiple) {
+	fsb->fsb.current_size_multiple = False;
+	UnmanageSizeMultiple(fsb);
+    }
+
+    strcpy(buf, XtName(widget));
+    for (ch = buf; *ch != '\0'; ch++) if (*ch == '-') *ch++ = '.';
+
+    changingSize = True;
+    XtVaSetValues(fsb->fsb.size_text_field_child, XmNvalue, buf, NULL);
+    changingSize = False;
+
+    SensitizeReset(fsb);
+    ValueChanged(fsb);
+}
+
+/* This makes sure the selected item is visible */
+
+static void ListSelectPos(
+    Widget w,
+    int pos,
+    Boolean notify)
+{
+    int topPos, items, visible;
+
+    XmListSelectPos(w, pos, notify);
+    
+    XtVaGetValues(w, XmNtopItemPosition, &topPos,
+		  XmNvisibleItemCount, &visible, XmNitemCount, &items, NULL);
+
+    if (pos >= topPos && pos < topPos + visible) return;
+    topPos = pos - (visible-1)/2;
+    if (topPos + visible > items) topPos = items - visible + 1;
+    if (topPos < 1) topPos = 1;
+
+    XtVaSetValues(w, XmNtopItemPosition, topPos, NULL);
+}
+
+/* The following function Copyright 1987, 1988 by Digital Equipment
+Corporation, Maynard, Massachusetts, and the Massachusetts Institute of
+Technology, Cambridge, Massachusetts. */
+
+static String GetRootDirName(String buf)
+{
+#ifndef X_NOT_POSIX
+     uid_t uid;
+#else
+     int uid;
+     extern int getuid();
+#ifndef SYSV386
+     extern struct passwd *getpwuid(), *getpwnam();
+#endif
+#endif
+     struct passwd *pw;
+     static char *ptr = NULL;
+
+     if (ptr == NULL) {
+        if (!(ptr = getenv("HOME"))) {
+            if ((ptr = getenv("USER")) != NULL) pw = getpwnam(ptr);
+            else {
+                uid = getuid();
+                pw = getpwuid(uid);
+            }
+            if (pw) ptr = pw->pw_dir;
+            else {
+                ptr = NULL;
+                *buf = '\0';
+            }
+        }
+     }
+
+     if (ptr)
+        (void) strcpy(buf, ptr);
+
+     buf += strlen(buf);
+     *buf = '/';
+     buf++;
+     *buf = '\0';
+     return buf;
+}
+
+static void WriteBlendLine(
+    FILE *f,
+    String family, String face, String blend, String name,
+    int axes,
+    float *p)
+{
+    register char *ch;
+    int i;
+
+    ch = family;
+    while (*ch != '\0') {
+	if (*ch == ',' || *ch == '\\') (void) putc('\\', f);
+	(void) putc(*ch++, f);
+    }
+    putc(',', f);
+    ch = face;
+    while (*ch != '\0') {
+	if (*ch == ',' || *ch == '\\') (void) putc('\\', f);
+	(void) putc(*ch++, f);
+    }
+    putc(',', f);
+    ch = blend;
+    while (*ch != '\0') {
+	if (*ch == ',' || *ch == '\\') (void) putc('\\', f);
+	(void) putc(*ch++, f);
+    }
+    (void) putc(',', f);
+    ch = name;
+    while (*ch != '\0') {
+	if (*ch == ',' || *ch == '\\') (void) putc('\\', f);
+	(void) putc(*ch++, f);
+    }
+    for (i = 0; i < axes; i++) fprintf(f, ",%f", p[i]);
+    (void) putc('\n', f);
+}
+
+static void WriteBlends(FontSelectionBoxWidget fsb)
+{
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+    String blendEnv;
+    char homeDir[PATH_BUF_SIZE];
+    FILE *blendFile = NULL;
+    char fileName[PATH_BUF_SIZE];
+
+    if (!fsb->fsb.blends_changed) return;
+
+    blendEnv = getenv("DPSFONTRC");
+
+    if (blendEnv != NULL) blendFile = fopen(blendEnv, "w");
+
+    if (blendFile == NULL) {
+	(void) GetRootDirName(homeDir);
+	sprintf(fileName, "%s/.dpsfontrc", homeDir);
+	blendFile = fopen(fileName, "w");
+
+	if (blendFile == NULL) return;
+    }
+
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->blend_data != NULL) {
+		for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		    WriteBlendLine(blendFile, ff->family_name, f->face_name,
+				   b->blend_name, b->font_name,
+				   f->blend_data->num_axes, b->data);
+		}
+	    }
+	}
+    }
+
+    fclose(blendFile);
+    fsb->fsb.blends_changed = False;
+}
+
+static Boolean ParseBlendLine(
+    String buf, String family, String face, String blend, String name,
+    float *p)
+{
+    char *src, *dst;
+    int i;
+    float f;
+
+    src = buf;
+    dst = family;
+    while (*src != ',' && *src != '\0') {
+	if (*src == '\\') src++;
+	if (*src == '\0') return False;
+	*dst++ = *src++;
+    }
+    if (*src == '\0') return False;
+    *dst = '\0';
+    src++;
+    dst = face;
+    while (*src != ',' && *src != '\0') {
+	if (*src == '\\') src++;
+	if (*src == '\0') return False;
+	*dst++ = *src++;
+    }
+    if (*src == '\0') return False;
+    *dst = '\0';
+    src++;
+    dst = blend;
+    while (*src != ',' && *src != '\0') {
+	if (*src == '\\') src++;
+	if (*src == '\0') return False;
+	*dst++ = *src++;
+    }
+    if (*src == '\0') return False;
+    *dst = '\0';
+    src++;
+    dst = name;
+    while (*src != ',' && *src != '\0') {
+	if (*src == '\\') src++;
+	if (*src == '\0') return False;
+	*dst++ = *src++;
+    }
+    if (*src == '\0') return False;
+    *dst = '\0';
+    for (i = 0; i < MAX_AXES; i++) {
+	src++;
+	if (!ScanFloat(src, &f, &src)) {
+	    for (/**/; i < MAX_AXES; i++) p[i] = 0;
+	    return True;;
+	}
+	else p[i] = f;
+    }
+    return True;
+}
+
+static void ReadBlends(FontSelectionBoxWidget fsb)
+{
+    String blendEnv;
+    char homeDir[PATH_BUF_SIZE];
+    FILE *blendFile = NULL;
+    char fileName[PATH_BUF_SIZE];
+#define BUF 256
+    char buf[BUF+1], family[BUF+1], face[BUF+1], blend[BUF+1], name[BUF+1];
+    char *cfamily, *cface;
+    float p[MAX_AXES];
+    FontRec *f;
+    FontFamilyRec *ff = 0;
+    BlendRec *b, *newb, **lastb;
+    char *spaceBlend;	    
+    char *lastFamily = NULL;
+    int cmp, i;
+
+    blendEnv = getenv("DPSFONTRC");
+
+    if (blendEnv != NULL) blendFile = fopen(blendEnv, "r");
+
+    if (blendFile == NULL) {
+	(void) GetRootDirName(homeDir);
+	sprintf(fileName, "%s/.dpsfontrc", homeDir);
+	blendFile = fopen(fileName, "r");
+
+	if (blendFile == NULL) return;
+    }
+
+    while (1) {
+	if (fgets(buf, BUF, blendFile) == NULL) {
+	    fclose(blendFile);
+	    return;
+	}
+	if (ParseBlendLine(buf, family, face, blend, name, p)) {
+	    cfamily = Canonical(family);
+	    if (cfamily != lastFamily) {
+		for (ff = fsb->fsb.known_families;
+		     ff != NULL && ff->family_name != cfamily;
+		     ff = ff->next) {}
+	    }
+	    if (ff == NULL) continue;
+	    lastFamily = cfamily;
+	    cface = Canonical(face);
+	    for (f = ff->fonts; f != NULL && f->face_name != cface;
+		 f = f->next) {}
+	    /* If the blend data is NULL, we have a blend line for a font
+	       that we don't believe is a MM font.  Ignore it */
+	    if (f != NULL && f->blend_data != NULL) {
+		lastb = &f->blend_data->blends;
+		cmp = -1;
+		for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		    cmp = strcmp(blend, b->blend_name);
+		    if (cmp < 0) break;
+		    lastb = &b->next;
+		}
+		if (cmp != 0) {
+		    newb = XtNew(BlendRec);
+		    newb->blend_name = Canonical(blend);
+		    newb->CS_blend_name = CS(newb->blend_name, (Widget) fsb);
+
+		    spaceBlend = (char *) XtMalloc(strlen(blend) + 4);
+		    spaceBlend[0] = spaceBlend[1] = spaceBlend[2] = ' ';
+		    strcpy(spaceBlend+3, blend);
+		    newb->CS_space_blend_name = CS(spaceBlend, (Widget) fsb);
+		    XtFree((XtPointer) spaceBlend);
+
+		    for (i = 0; i < MAX_AXES; i++) newb->data[i] = p[i];
+		    newb->font_name = Canonical(name);
+
+		    f->blend_count++;
+		    ff->blend_count++;
+
+		    newb->next = b;
+		    *lastb = newb;
+		}
+	    }
+	}
+    }
+}
+
+static void SetUpFaceList(
+    FontSelectionBoxWidget fsb,
+    FontFamilyRec *ff)
+{
+    FontRec *f;
+    BlendRec *b;
+    XmString *CSfaces;
+    Boolean multiple = False;
+    int i;
+
+    for (f = ff->fonts; f != NULL; f = f->next) {
+	if (f->blend_data != NULL) {
+	    multiple = True;
+	    break;
+	}
+    }
+    if (multiple) ManageMultipleMaster(fsb);
+    else UnmanageMultipleMaster(fsb);
+
+    CSfaces = (XmString *) XtCalloc(ff->font_count + ff->blend_count,
+				    sizeof(XmString));
+
+    i = 0;
+    for (f = ff->fonts; f != NULL; f = f->next) {
+	CSfaces[i++] = f->CS_face_name;
+	if (f->blend_data != NULL) {
+	    for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		CSfaces[i++] = b->CS_space_blend_name;
+	    }
+	}
+    }
+
+    XtVaSetValues(fsb->fsb.face_scrolled_list_child,
+		  XmNitemCount, ff->font_count + ff->blend_count,
+		  XmNitems, CSfaces, NULL);
+    XtFree((XtPointer) CSfaces);
+}
+
+/* ARGSUSED */
+
+static void DeleteMessage(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    XtDestroyWidget(widget);
+}
+
+static void FlushFont(
+    FontSelectionBoxWidget fsb,
+    FontRec *font)
+{
+    FontRec *f = 0, *f1;
+    FontFamilyRec *ff, *ff1;
+    Boolean previewedFamily = False;
+
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f == font) goto FOUND_BOGUS;
+	}
+    }
+
+FOUND_BOGUS:
+    if (f != NULL) {
+	for (f1 = ff->fonts; f1 != NULL; f1 = f1->next) {
+	    if (f1 == fsb->fsb.currently_previewed) {
+		previewedFamily = True;
+		break;
+	    }
+	}
+
+	if (ff->fonts == f) {
+	    ff->fonts = f->next;
+	} else {
+	    for (f1 = ff->fonts; f1 != NULL && f1->next != f; f1 = f1->next) {}
+	    if (f1 != NULL) f1->next = f->next;
+	}
+
+	ff->font_count--;
+	ff->blend_count -= f->blend_count;
+
+	if (f == fsb->fsb.currently_selected_face) {
+	    fsb->fsb.currently_selected_face = NULL;
+	    fsb->fsb.currently_selected_blend = NULL;
+	}
+
+	if (previewedFamily) SetUpFaceList(fsb, ff);
+
+	if (f == fsb->fsb.currently_previewed) {
+	    fsb->fsb.currently_previewed = NULL;
+	    fsb->fsb.currently_previewed_blend = NULL;
+	    ValueChanged(fsb);
+	}
+
+	/* We do not free the FontRec or FontFamilyRec.  In the long
+	   run we don't expect to leak much storage this way, since we
+	   shouldn't have many bogus fonts, and invalidating every 
+	   reference here, in the sampler, and in the creator isn't
+	   worth the small storage waste. */
+
+	if (ff->fonts == NULL) {
+	    if (fsb->fsb.known_families == ff) {
+		fsb->fsb.known_families = ff->next;
+	    } else {
+		for (ff1 = fsb->fsb.known_families;
+		     ff1 != NULL && ff1->next != ff; ff1 = ff1->next) {}
+		if (ff1 != NULL) ff1->next = ff->next;
+	    }
+
+	    fsb->fsb.family_count--;
+
+	    if (ff == fsb->fsb.currently_selected_family) {
+		fsb->fsb.currently_selected_family = NULL;
+	    }
+
+	    DisplayFontFamilies(fsb);
+	}
+    }
+}
+
+void _FSBFlushFont(
+    FontSelectionBoxWidget fsb,
+    FontRec *font)
+{
+    if (font == fsb->fsb.currently_previewed) _FSBBogusFont(fsb, font);
+    else FlushFont(fsb, font);
+}
+
+void _FSBBogusFont(
+    FontSelectionBoxWidget fsb,
+    FontRec *font)
+{
+    Widget message, w;
+
+    message = XmCreateInformationDialog((Widget) fsb, "invalidFontMessage",
+					(ArgList) NULL, 0);
+    w =	XmMessageBoxGetChild(message, XmDIALOG_CANCEL_BUTTON);
+    XtUnmanageChild(w);
+    w =	XmMessageBoxGetChild(message, XmDIALOG_HELP_BUTTON);
+    XtUnmanageChild(w);
+    XtAddCallback(message, XmNokCallback, DeleteMessage, (XtPointer) NULL);
+    
+    XtManageChild(message);
+
+    /* Now get this blasted thing out of here */
+    FlushFont(fsb, font);
+}
+
+void _FSBSetUpFaceList(
+    FontSelectionBoxWidget fsb,
+    Bool redisplay)
+{
+    FontRec *f;
+    BlendRec *b;
+    int i;
+
+    SetUpFaceList(fsb, fsb->fsb.currently_selected_family);
+    
+    f = fsb->fsb.currently_selected_family->fonts;
+    i = 1;
+    while (f != NULL) {
+	if (f == fsb->fsb.currently_selected_face) {
+	    if (f->blend_data != NULL) {
+		b = f->blend_data->blends;
+		if (fsb->fsb.currently_selected_blend != NULL) {
+		    i++;
+		    while (b != NULL &&
+			   b != fsb->fsb.currently_selected_blend) {
+			i++;
+			b = b->next;
+		    }
+		}
+	    }
+	    break;
+	} else {
+	    i += f->blend_count+1;
+	    f = f->next;
+	}
+    }
+
+    ListSelectPos(fsb->fsb.face_scrolled_list_child, i, False);
+    if (redisplay) ValueChanged(fsb);
+    fsb->fsb.blends_changed = True;
+}
+
+static String categories[][6] = {
+    {"Regular", "Roman", "Medium", "Book", "Light", NULL},
+    {"Italic", "Slanted", "Oblique", NULL},
+    {"Demi", "Semibold", "Heavy", "Bold", NULL},
+    {NULL},
+};
+
+#define NORMALINDEX 0][0
+#define ITALICINDEX 1][0
+#define BOLDINDEX 2][3
+#define DEMIINDEX 2][0
+#define LIGHTINDEX 0][4
+#define BOOKINDEX 0][3
+
+static String extraNormalFaces[] = {"Demi", "Semibold", NULL};
+
+static int MatchFaceName(
+    FSBFaceSelectCallbackRec *rec,
+    Boolean *gaveUp)
+{
+    int i, j, k, face;
+#define PIECEMAX 10
+    String pieces[PIECEMAX];
+    int numPieces;
+    int pass;
+    char *ch, *start, *compare;
+    char save;
+    static Boolean categoriesInited = False;
+    static char *canonicalBold, *canonicalLight, *canonicalBook;
+
+    *gaveUp = False;
+
+    if (!categoriesInited) {
+	for (i = 0; categories[i][0] != NULL; i++) {
+	    for (j = 0; categories[i][j] != NULL; j++) {
+		categories[i][j] = Canonical(categories[i][j]);
+	    }
+	}
+	for (i = 0; extraNormalFaces[i] != NULL; i++) {
+	    extraNormalFaces[i] = Canonical(extraNormalFaces[i]);
+	}
+	canonicalBold = categories[BOLDINDEX];
+	canonicalLight = categories[LIGHTINDEX];
+	canonicalBook = categories[BOOKINDEX];
+	categoriesInited = True;
+    }
+
+    if (rec->current_face == NULL || rec->current_face[0] == '\0') {
+	goto GIVE_UP;
+    }
+
+    /* First check for an exact match */
+
+    for (i = 0; i < rec->num_available_faces; i++) {
+	if (rec->available_faces[i] == rec->current_face) return i;
+    }
+
+    /* Try some category matching.  We make two passes; in the first pass
+       we remove "Bold" from the "Demi" family and "Light" and "Book" from
+       the "Regular" family; in the second pass we include them.  We ignore
+       leading digits in the face name.  */
+
+    categories[BOLDINDEX] = categories[LIGHTINDEX] =
+	    categories[BOOKINDEX] = NULL;
+
+    i = 0;
+    ch = rec->current_face;
+    while (*ch == ' ' || isdigit(*ch)) ch++;
+    start = ch;
+
+    while (1) {
+	while (*ch != ' ' && *ch != '\0') ch++;
+	save = *ch;
+	*ch = '\0';
+	compare = Canonical(start);
+	for (j = 0; categories[j][0] != NULL; j++) {
+	    for (k = 0; categories[j][k] != NULL; k++) {
+		if (compare == categories[j][k]) {
+		    pieces[i++] = categories[j][0];
+		    goto FOUND_PIECE;
+		}
+	    }
+	}
+	pieces[i++] = compare;	/* A unique piece */
+FOUND_PIECE:
+	*ch = save;
+	while (*ch == ' ') ch++;
+	if (*ch == '\0') break;
+	if (i >= PIECEMAX) goto GIVE_UP;
+	start = ch;
+    }
+    numPieces = i;
+    if (numPieces == 0) goto GIVE_UP;
+
+    /* Special case starting with the italic category */
+
+    if (pieces[0] == categories[ITALICINDEX] && numPieces < PIECEMAX-1) {
+	for (i = numPieces; i > 0; i--) pieces[i] = pieces[i-1];
+	pieces[0] = categories[NORMALINDEX];
+	numPieces++;
+    }
+
+    for (pass = 0; pass < 2; pass++) {
+	if (pass == 1) {
+	    categories[BOLDINDEX] = canonicalBold;
+	    categories[LIGHTINDEX] = canonicalLight;
+	    categories[BOOKINDEX] = canonicalBook;
+	    for (i = 0; i < numPieces; i++) {
+		if (pieces[i] == canonicalBold) {
+		    pieces[i] = categories[DEMIINDEX];
+		} else if (pieces[i] == canonicalLight) {
+		    pieces[i] = categories[NORMALINDEX];
+		}  else if (pieces[i] == canonicalBook) {
+		    pieces[i] = categories[NORMALINDEX];
+		}
+	    }
+	}
+
+	/* Now match against each face */
+
+	for (face = 0; face < rec->num_available_faces; face++) {
+	    i = 0;
+	    ch = rec->available_faces[face];
+	    while (*ch == ' ' || isdigit(*ch)) ch++;
+	    start = ch;
+
+	    while (1) {
+		while (*ch != ' ' && *ch != '\0') ch++;
+		save = *ch;
+		*ch = '\0';
+		compare = Canonical(start);
+		for (j = 0; categories[j][0] != NULL; j++) {
+		    for (k = 0; categories[j][k] != NULL; k++) {
+			if (compare == categories[j][k]) {
+			    compare = categories[j][0];
+			    goto MATCH;
+			}
+		    }
+		}
+    MATCH:
+		/* Special case matching the italic category again */
+
+		if (i == 0 && compare == categories[ITALICINDEX] &&
+		    pieces[0] == categories[NORMALINDEX] &&
+		    numPieces > 1 &&
+		    pieces[1] == categories[ITALICINDEX]) i = 1;
+
+		if (pieces[i] != compare) {
+		    *ch = save;
+		    goto NEXT_FACE;
+		} else i++;
+
+		*ch = save;
+		while (*ch == ' ') ch++;
+		if (*ch == '\0') break;
+		if (i >= numPieces) goto NEXT_FACE;
+		start = ch;
+	    }
+	    if (i == numPieces) return face;	/* Found a match! */
+    NEXT_FACE:		
+	    ;
+	}
+    }
+
+    /* Couldn't find a match.  Look for a "normal face".  Make sure "Light"
+       and "Book" are installed. Again, ignore leading spaces.  */
+GIVE_UP:
+    *gaveUp = True;
+    categories[LIGHTINDEX] = canonicalLight;
+    categories[BOOKINDEX] = canonicalBook;
+
+    for (i = 0; categories[0][i] != NULL; i++) {
+	for (face = 0; face < rec->num_available_faces; face++) {
+	    compare = rec->available_faces[face];
+	    while (*compare == ' ' || isdigit(*compare)) compare++;
+	    if (compare != rec->available_faces[face]) {
+		compare = Canonical(compare);
+	    }
+	    if (categories[0][i] == compare) return face;
+	}
+    }
+
+    for (i = 0; extraNormalFaces[i] != NULL; i++) {
+	for (face = 0; face < rec->num_available_faces; face++) {
+	    compare = rec->available_faces[face];
+	    while (*compare == ' ' || isdigit(*compare)) compare++;
+	    if (compare != rec->available_faces[face]) {
+		compare = Canonical(compare);
+	    }
+	    if (extraNormalFaces[i] == compare) return face;
+	}
+    }
+    
+    /* Oh, well.  Use the first one */
+    return 0;
+}
+
+static void GetInitialFace(
+    FontSelectionBoxWidget fsb,
+    FontFamilyRec *ff)
+{
+    FSBFaceSelectCallbackRec rec;
+    String *faces;
+    int i, j;
+    FontRec *f;
+    Boolean junk;
+
+    faces = (String *) XtMalloc(ff->font_count * sizeof(String));
+    i = 0;
+    for (f = ff->fonts; f != NULL; f = f->next) faces[i++] = f->face_name;
+
+    rec.available_faces = faces;
+    rec.num_available_faces = ff->font_count;
+
+    if (fsb->fsb.currently_selected_face != NULL) {
+	rec.current_face = fsb->fsb.currently_selected_face->face_name;
+    } else rec.current_face = fsb->fsb.font_face;
+
+    rec.new_face = NULL;
+
+    XtCallCallbackList((Widget) fsb, fsb->fsb.face_select_callback, &rec);
+    if (rec.new_face != NULL) {
+	for (i = 0; i < ff->font_count; i++) {
+	    if (rec.new_face == faces[i]) break;
+	}
+    }
+    if (rec.new_face == NULL || i >= ff->font_count) {
+	i = MatchFaceName(&rec, &junk);
+    }
+    XtFree((XtPointer) faces);
+
+    j = 0;
+    for (f = ff->fonts; i != 0; f= f->next) {
+	j += f->blend_count + 1;
+	i--;
+    }
+    
+    ListSelectPos(fsb->fsb.face_scrolled_list_child, j+1, False);
+    fsb->fsb.currently_selected_face = f;
+    fsb->fsb.currently_selected_blend = NULL;
+}
+
+/* ARGSUSED */
+
+static void FamilySelect(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    XmListCallbackStruct *listCB = (XmListCallbackStruct *) callData;
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+    FontFamilyRec *ff = fsb->fsb.known_families;
+    int i;
+
+    if (fsb->fsb.current_family_multiple) {
+	fsb->fsb.current_family_multiple = False;
+	UnmanageFamilyMultiple(fsb);
+    }
+
+    /* List uses 1-based addressing!! */
+    for (i = 1; i < listCB->item_position; i++) ff = ff->next;
+
+    fsb->fsb.currently_selected_family = ff;
+
+    SensitizeReset(fsb);
+    SetUpFaceList(fsb, ff);
+    if (!fsb->fsb.current_face_multiple) GetInitialFace(fsb, ff);
+    ValueChanged(fsb);
+}
+
+/* ARGSUSED */
+
+static void FaceSelect(
+    Widget widget,
+    XtPointer clientData, XtPointer callData)
+{
+    XmListCallbackStruct *listCB = (XmListCallbackStruct *) callData;
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) clientData;
+    FontRec *f;
+    BlendRec *b;
+    int n;
+
+    if (fsb->fsb.currently_selected_family == NULL) return;
+    f = fsb->fsb.currently_selected_family->fonts;
+
+    if (fsb->fsb.current_face_multiple) {
+	fsb->fsb.current_face_multiple = False;
+	UnmanageFaceMultiple(fsb);
+    }
+
+    /* List uses 1-based addressing!! */
+    n = 0;
+    while (1) {
+	n += f->blend_count + 1;
+	if (n >= listCB->item_position) {
+	    n -= f->blend_count;
+	    if (n == listCB->item_position) b = NULL;
+	    else for (b = f->blend_data->blends; n < listCB->item_position - 1;
+		      b = b->next) n++;
+	    break;
+	}
+	f = f->next;
+    }
+
+    fsb->fsb.currently_selected_face = f;
+    fsb->fsb.currently_selected_blend = b;
+
+    SensitizeReset(fsb);
+    ValueChanged(fsb);
+}
+
+static void CreateSizeMenu(
+    FontSelectionBoxWidget fsb,
+    Boolean destroyOldChildren)
+{
+    Arg args[20];
+    int i, j;
+    Widget *sizes;
+    char buf[20];
+    Widget *children;
+    Cardinal num_children;
+    XmString csName;
+    char *ch;
+
+    if (destroyOldChildren) {
+	XtVaGetValues(fsb->fsb.size_menu, XtNchildren, &children,
+		      XtNnumChildren, &num_children, NULL);
+
+	/* Don't destroy first child ("other") */
+	for (j = 1; (Cardinal)j < num_children; j++) XtDestroyWidget(children[j]);
+
+	sizes = (Widget *) XtMalloc((fsb->fsb.size_count+1) * sizeof(Widget));
+	sizes[0] = children[0];
+    } else {
+	i = 0;
+	sizes = (Widget *) XtMalloc((fsb->fsb.size_count+1) * sizeof(Widget));
+	fsb->fsb.other_size = sizes[0] =
+		XtCreateManagedWidget("other", xmPushButtonGadgetClass,
+				  fsb->fsb.size_menu, args, i);
+    }
+
+    for (j = 0; j < fsb->fsb.size_count; j++) {
+	(void) sprintf(buf, "%g", fsb->fsb.sizes[j]);
+	csName = UnsharedCS(buf);
+	for (ch = buf; *ch != '\0'; ch++) if (*ch == '.') *ch = '-';
+	i = 0;
+	XtSetArg(args[i], XmNlabelString, csName);			i++;
+	sizes[j+1] =
+		XmCreatePushButtonGadget(fsb->fsb.size_menu, buf, args, i);
+	XmStringFree(csName);
+	XtAddCallback(sizes[j+1], XmNactivateCallback,
+		      SetSize, (XtPointer) fsb);
+    }
+    XtManageChildren(sizes, j+1);
+    XtFree((char *) sizes);
+}
+
+static void CreateChildren(FontSelectionBoxWidget fsb)
+{
+    Arg args[20];
+    int i;
+    Widget form;
+
+    i = 0;
+    fsb->fsb.pane_child =
+	    XtCreateManagedWidget("pane", xmPanedWindowWidgetClass,
+				  (Widget) fsb, args, i);
+
+    i = 0;
+    fsb->fsb.preview_child =
+	    XtCreateManagedWidget("preview", xmDrawingAreaWidgetClass,
+				  fsb->fsb.pane_child, args, i);
+    XtAddCallback(fsb->fsb.preview_child, XmNexposeCallback,
+		  PreviewText, (XtPointer) fsb);
+    XtAddCallback(fsb->fsb.preview_child, XmNresizeCallback,
+		  ResizePreview, (XtPointer) fsb);
+
+    i = 0;	
+    form = XtCreateManagedWidget("panel", xmFormWidgetClass,
+				 fsb->fsb.pane_child, args, i);
+    fsb->fsb.panel_child = form;
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.ok_button_child =
+	    XtCreateManagedWidget("okButton", xmPushButtonWidgetClass,
+				  form, args, i);
+    XtAddCallback(fsb->fsb.ok_button_child, XmNactivateCallback,
+		  OKCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNleftWidget,fsb->fsb.ok_button_child );		i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.apply_button_child =
+	    XtCreateManagedWidget("applyButton", xmPushButtonWidgetClass,
+				  form, args, i);
+    XtAddCallback(fsb->fsb.apply_button_child, XmNactivateCallback,
+		  ApplyCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNleftWidget,fsb->fsb.apply_button_child );	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.reset_button_child =
+	    XtCreateManagedWidget("resetButton", xmPushButtonWidgetClass,
+				  form, args, i);
+    XtAddCallback(fsb->fsb.reset_button_child, XmNactivateCallback,
+		  ResetCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNleftWidget,fsb->fsb.reset_button_child );	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.cancel_button_child =
+	    XtCreateManagedWidget("cancelButton", xmPushButtonWidgetClass,
+				  form, args, i);
+    XtAddCallback(fsb->fsb.cancel_button_child, XmNactivateCallback,
+		  CancelCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.ok_button_child);	i++;
+    fsb->fsb.separator_child =
+	    XtCreateManagedWidget("separator", xmSeparatorGadgetClass,
+				  form, args, i);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.separator_child);	i++;
+    fsb->fsb.size_label_child =
+	    XtCreateManagedWidget("sizeLabel", xmLabelWidgetClass,
+				  form, args, i);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNleftWidget, fsb->fsb.size_label_child);	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.size_label_child);	i++;
+    fsb->fsb.size_text_field_child =
+	    XtCreateManagedWidget("sizeTextField", xmTextFieldWidgetClass,
+				  form, args, i);
+    XtAddCallback(fsb->fsb.size_text_field_child, XmNvalueChangedCallback,
+		  SizeSelect, (XtPointer) fsb);
+    XtAddCallback(fsb->fsb.size_text_field_child, XmNmodifyVerifyCallback,
+		  TextVerify, (XtPointer) fsb);
+
+    i = 0;
+    fsb->fsb.size_menu = XmCreatePulldownMenu(form, "sizeMenu", args, i);
+
+    CreateSizeMenu(fsb, False);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNleftWidget, fsb->fsb.size_text_field_child);	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.size_label_child);	i++;
+    XtSetArg(args[i], XmNsubMenuId, fsb->fsb.size_menu);		i++;
+    fsb->fsb.size_option_menu_child =
+	    XmCreateOptionMenu(form, "sizeOptionMenu", args, i);
+    XtManageChild(fsb->fsb.size_option_menu_child);
+
+    i = 0;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNleftWidget, fsb->fsb.size_option_menu_child);	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.separator_child);	i++;
+    fsb->fsb.size_multiple_label_child =
+	    XtCreateWidget("sizeMultipleLabel", xmLabelWidgetClass,
+			   form, args, i);
+
+    i = 0;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.size_label_child);	i++;
+    fsb->fsb.preview_button_child =
+	    XtCreateManagedWidget("previewButton", xmPushButtonWidgetClass,
+				  form, args, i);
+    XtAddCallback(fsb->fsb.preview_button_child, XmNactivateCallback,
+		  PreviewCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNrightWidget, fsb->fsb.preview_button_child);	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET);	i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.preview_button_child);	i++;
+    fsb->fsb.sampler_button_child =
+	    XtCreateWidget("samplerButton", xmPushButtonWidgetClass,
+				  form, args, i);
+    if (fsb->fsb.show_sampler_button) {
+	XtManageChild(fsb->fsb.sampler_button_child);
+    }
+    XtAddCallback(fsb->fsb.sampler_button_child, XmNactivateCallback,
+		  ShowSamplerCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNrightPosition, 50);				i++;
+    fsb->fsb.family_label_child =
+	    XtCreateManagedWidget("familyLabel", xmLabelGadgetClass,
+				  form, args, i);
+
+    i = 0;
+    XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM);			i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNleftPosition, 50);				i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.face_label_child =
+	    XtCreateManagedWidget("faceLabel", xmLabelGadgetClass,
+				  form, args, i);
+
+    /* The next two must be widgets in order to be reversed in color */
+
+    i = 0;
+    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNtopWidget, fsb->fsb.family_label_child);	i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNrightPosition, 50);				i++;
+    fsb->fsb.family_multiple_label_child =
+	    XtCreateWidget("familyMultipleLabel", xmLabelWidgetClass,
+			   form, args, i);
+
+    i = 0;
+    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNtopWidget, fsb->fsb.face_label_child);		i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNleftPosition, 50);				i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.face_multiple_label_child =
+	    XtCreateWidget("faceMultipleLabel", xmLabelWidgetClass,
+			   form, args, i);
+
+    i = 0; 
+    XtSetArg(args[i], XmNitemCount, 1);					i++;
+    XtSetArg(args[i], XmNitems, &CSempty);				i++;
+    fsb->fsb.family_scrolled_list_child =
+	    XmCreateScrolledList(form, "familyScrolledList", args, i);
+    XtAddCallback(fsb->fsb.family_scrolled_list_child,
+		  XmNbrowseSelectionCallback, FamilySelect, (XtPointer) fsb);
+    XtAddCallback(fsb->fsb.family_scrolled_list_child,
+		  XmNdefaultActionCallback,
+		  PreviewDoubleClick, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNtopWidget, fsb->fsb.family_label_child);	i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.size_text_field_child);	i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM);		i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNrightPosition, 50);				i++;
+    XtSetValues(XtParent(fsb->fsb.family_scrolled_list_child), args, i);
+    XtManageChild(fsb->fsb.family_scrolled_list_child);
+
+    i = 0;
+    XtSetArg(args[i], XmNitemCount, 1);					i++;
+    XtSetArg(args[i], XmNitems, &CSempty);				i++;
+    fsb->fsb.face_scrolled_list_child =
+	    XmCreateScrolledList(form, "faceScrolledList", args, i);
+    XtAddCallback(fsb->fsb.face_scrolled_list_child,
+		  XmNbrowseSelectionCallback, FaceSelect, (XtPointer) fsb);
+    XtAddCallback(fsb->fsb.face_scrolled_list_child,
+		  XmNdefaultActionCallback, PreviewDoubleClick,
+		  (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNtopAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNtopWidget, fsb->fsb.face_label_child);		i++;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.size_text_field_child);	i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNleftPosition, 50);				i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
+    XtSetValues(XtParent(fsb->fsb.face_scrolled_list_child), args, i);
+    XtManageChild(fsb->fsb.face_scrolled_list_child);
+
+    i = 0;
+    XtSetArg(args[i], XmNbottomAttachment, XmATTACH_WIDGET);		i++;
+    XtSetArg(args[i], XmNbottomWidget, fsb->fsb.size_text_field_child);	i++;
+    XtSetArg(args[i], XmNleftAttachment, XmATTACH_POSITION);		i++;
+    XtSetArg(args[i], XmNleftPosition, 50);				i++;
+    XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM);		i++;
+    fsb->fsb.multiple_master_button_child =
+	    XtCreateWidget("multipleMasterButton", xmPushButtonWidgetClass,
+			   form, args, i);
+    XtAddCallback(fsb->fsb.multiple_master_button_child, XmNactivateCallback,
+		  ShowCreatorCallback, (XtPointer) fsb);
+
+    i = 0;
+    XtSetArg(args[i], XmNdefaultButton, fsb->fsb.ok_button_child);	i++;
+    XtSetValues(form, args, i);
+}
+
+static void DisplayFontFamilies(FontSelectionBoxWidget fsb)
+{
+    FontFamilyRec *ff;
+    XmString *CSlist, *str;
+    
+    CSlist = (XmString *) XtMalloc(fsb->fsb.family_count * sizeof(XmString));
+    str = CSlist;
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	*str++ = UnsharedCS(ff->family_name);
+    }
+    
+    XtVaSetValues(fsb->fsb.family_scrolled_list_child,
+		  XmNitemCount, fsb->fsb.family_count,
+		  XmNitems, CSlist, NULL);		
+
+    /* The list makes a copy, so we can delete the list */
+    XtFree((char *) CSlist);
+}
+
+static void SetUpCurrentFontFromName(FontSelectionBoxWidget fsb)
+{
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+    int i, j;
+
+    fsb->fsb.currently_selected_face = NULL;
+    fsb->fsb.currently_selected_family = NULL;
+    fsb->fsb.currently_selected_blend = NULL;
+
+    if (fsb->fsb.font_name_multiple || fsb->fsb.font_name == NULL) {
+	fsb->fsb.font_name = NULL;
+	fsb->fsb.font_family = NULL;
+	fsb->fsb.font_blend = NULL;
+	fsb->fsb.font_face = NULL;
+	if (fsb->fsb.font_name_multiple) {
+	    fsb->fsb.current_family_multiple = True;
+	    fsb->fsb.current_face_multiple = True;
+	    ManageFamilyMultiple(fsb);
+	    ManageFaceMultiple(fsb);
+	}
+	XmListDeselectAllItems(fsb->fsb.family_scrolled_list_child);
+	XmListDeselectAllItems(fsb->fsb.face_scrolled_list_child);
+	XmListDeleteAllItems(fsb->fsb.face_scrolled_list_child);
+	XmListAddItem(fsb->fsb.face_scrolled_list_child, CSempty, 1);
+	return;
+    }
+
+    if (!fsb->fsb.font_name_multiple) {
+	fsb->fsb.current_family_multiple = False;
+	fsb->fsb.current_face_multiple = False;
+	UnmanageFamilyMultiple(fsb);
+	UnmanageFaceMultiple(fsb);
+    }
+
+    fsb->fsb.font_name = Canonical(fsb->fsb.font_name);
+    i = 1;
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	j = 1;
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == fsb->fsb.font_name) {
+		fsb->fsb.font_family = ff->family_name;
+		fsb->fsb.font_face = f->face_name;
+		SetUpFaceList(fsb, ff);
+		ListSelectPos(fsb->fsb.family_scrolled_list_child, i, False);
+		ListSelectPos(fsb->fsb.face_scrolled_list_child, j, False);
+		fsb->fsb.currently_selected_face = f;
+		fsb->fsb.currently_selected_family = ff;
+		fsb->fsb.currently_selected_blend = NULL;
+		return;
+	    }
+	    j++;
+	    if (f->blend_data != NULL && f->blend_data->blends != NULL) {
+		for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		    if (b->font_name == fsb->fsb.font_name) {
+			fsb->fsb.font_family = ff->family_name;
+			fsb->fsb.font_face = f->face_name;
+			SetUpFaceList(fsb, ff);
+			ListSelectPos(fsb->fsb.family_scrolled_list_child, i,
+				      False);
+			ListSelectPos(fsb->fsb.face_scrolled_list_child, j,
+				      False);
+			fsb->fsb.currently_selected_face = f;
+			fsb->fsb.currently_selected_family = ff;
+			fsb->fsb.currently_selected_blend = b;
+			return;
+		    }
+		    j++;
+		}
+	    }
+
+	}
+	i++;
+    }
+ 
+   /* Didn't find it! */
+    fsb->fsb.font_name = NULL;
+    fsb->fsb.font_family = NULL;
+    fsb->fsb.font_face = NULL;
+    fsb->fsb.font_blend = NULL;
+    XmListDeselectAllItems(fsb->fsb.family_scrolled_list_child);
+    XmListDeselectAllItems(fsb->fsb.face_scrolled_list_child);
+    XmListDeleteAllItems(fsb->fsb.face_scrolled_list_child);
+    XmListAddItem(fsb->fsb.face_scrolled_list_child, CSempty, 1);
+}
+
+static void SetUpCurrentFontFromFamilyFace(FontSelectionBoxWidget fsb)
+{
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+    int i;
+
+    fsb->fsb.currently_selected_face = NULL;
+    fsb->fsb.currently_selected_family = NULL;
+    fsb->fsb.currently_selected_blend = NULL;
+
+    if (fsb->fsb.font_family_multiple) {
+	fsb->fsb.font_family = NULL;
+	fsb->fsb.current_family_multiple = True;
+	ManageFamilyMultiple(fsb);
+    } else {
+	fsb->fsb.current_family_multiple = False;
+	UnmanageFamilyMultiple(fsb);
+    }
+
+    if (fsb->fsb.font_face_multiple) {
+	fsb->fsb.font_face = NULL;
+	fsb->fsb.current_face_multiple = True;
+	ManageFaceMultiple(fsb);
+    } else {
+	fsb->fsb.current_face_multiple = False;
+	UnmanageFaceMultiple(fsb);
+    }
+
+    fsb->fsb.font_name_multiple =
+	    fsb->fsb.font_family_multiple || fsb->fsb.font_face_multiple;
+
+    if (fsb->fsb.font_family != NULL) {
+	fsb->fsb.font_family = Canonical(fsb->fsb.font_family);
+	i = 1;
+	for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	    if (fsb->fsb.font_family == ff->family_name) {
+		ListSelectPos(fsb->fsb.family_scrolled_list_child, i, False);
+		fsb->fsb.currently_selected_family = ff;
+		SetUpFaceList(fsb, ff);
+		break;
+	    }
+	    i++;
+	}
+	if (ff == NULL) fsb->fsb.font_family = NULL;
+    }   
+	
+    if (fsb->fsb.font_family == NULL) {
+	fsb->fsb.font_face = NULL;
+	fsb->fsb.font_blend = NULL;
+	fsb->fsb.font_name = NULL;
+	XmListDeselectAllItems(fsb->fsb.family_scrolled_list_child);
+	XmListDeselectAllItems(fsb->fsb.face_scrolled_list_child);
+	XmListDeleteAllItems(fsb->fsb.face_scrolled_list_child);
+	XmListAddItem(fsb->fsb.face_scrolled_list_child, CSempty, 1);
+	return;
+    }
+
+    if (fsb->fsb.font_face != NULL) {
+	fsb->fsb.font_face = Canonical(fsb->fsb.font_face);
+
+	i = 1;
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (fsb->fsb.font_face == f->face_name) {
+		fsb->fsb.currently_selected_face = f;
+		if (fsb->fsb.font_blend != NULL) {
+		    fsb->fsb.font_blend = Canonical(fsb->fsb.font_blend);
+		    for (b = f->blend_data->blends; b != NULL; b = b->next) {
+			i++;
+			if (b->blend_name == fsb->fsb.font_blend) {
+			    fsb->fsb.currently_selected_blend = b;
+			    break;
+			}
+		    }
+		    if (b == NULL) {
+			fsb->fsb.font_blend = NULL;
+			i -= f->blend_count;
+		    }
+		}
+		ListSelectPos(fsb->fsb.face_scrolled_list_child, i, False);
+		break;
+	    }
+	    i += f->blend_count + 1;
+	}
+	if (f == NULL) fsb->fsb.font_face = NULL;
+    } else {
+	f = NULL;
+	XmListDeselectAllItems(fsb->fsb.face_scrolled_list_child);
+    }
+
+    if (f == NULL && !fsb->fsb.font_face_multiple) GetInitialFace(fsb, ff);
+}
+
+static void SetUpCurrentFont(FontSelectionBoxWidget fsb)
+{
+    if (fsb->fsb.use_font_name) SetUpCurrentFontFromName(fsb);
+    else SetUpCurrentFontFromFamilyFace(fsb);
+}
+
+static void SetUpCurrentSize(FontSelectionBoxWidget fsb)
+{
+    char buf[20];
+
+    if (fsb->fsb.font_size_multiple) {
+	changingSize = True;
+	XtVaSetValues(fsb->fsb.size_text_field_child, XmNvalue, "", NULL);
+	changingSize = False;
+	fsb->fsb.current_size_multiple = True;
+	ManageSizeMultiple(fsb);
+	return;
+    } else UnmanageSizeMultiple(fsb);
+    
+    if (fsb->fsb.currently_selected_size == 0.0) {
+	sprintf(buf, "%g", fsb->fsb.font_size);
+    } else sprintf(buf, "%g", fsb->fsb.currently_selected_size);
+
+    changingSize = True;
+    XtVaSetValues(fsb->fsb.size_text_field_child, XmNvalue, buf, NULL);
+    changingSize = False;
+}
+
+static void SetUpCurrentSelections(FontSelectionBoxWidget fsb)
+{
+    SetUpCurrentFont(fsb);
+    SetUpCurrentSize(fsb);
+    if (fsb->fsb.preview_on_change) DoPreview(fsb, False);
+    DoValueChangedCallback(fsb);
+}
+
+/* ARGSUSED */
+
+static void Initialize(
+    Widget request, Widget new,
+    ArgList args,
+    Cardinal *num_args)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) new;
+    Bool inited;
+    char version[20];
+
+    /* Verify size list */
+
+    if (fsb->fsb.size_count > 0 && fsb->fsb.sizes == NULL) {
+	XtAppWarningMsg(XtWidgetToApplicationContext(new),
+			"initializeFontBox", "sizeMismatch",
+			"FontSelectionBoxError",
+			"Size count specified but no sizes present",
+			(String *) NULL, (Cardinal *) NULL);
+	fsb->fsb.size_count = 0;
+    }
+
+    if (fsb->fsb.size_count < 0) {
+	XtAppWarningMsg(XtWidgetToApplicationContext(new),
+			"initializeFontBox", "negativeSize",
+			"FontSelectionBoxError",
+			"Size count should not be negative",
+			(String *) NULL, (Cardinal *) NULL);
+	fsb->fsb.size_count = 0;
+    }
+
+    if (fsb->fsb.max_pending_deletes <= 0) {
+	XtAppWarningMsg(XtWidgetToApplicationContext(new),
+			"initializeFontBox", "nonPositivePendingDelete",
+			"FontSelectionBoxError",
+			"Pending delete max must be positive",
+			(String *) NULL, (Cardinal *) NULL);
+	fsb->fsb.max_pending_deletes = 1;
+    }
+
+    /* Copy strings.  SetUpCurrentSelection will copy the font strings */
+
+    if (fsb->fsb.preview_string != NULL) {
+	fsb->fsb.preview_string = XtNewString(fsb->fsb.preview_string);
+    }
+    if (fsb->fsb.default_resource_path != NULL) {
+	fsb->fsb.default_resource_path =
+		XtNewString(fsb->fsb.default_resource_path);
+    }
+    if (fsb->fsb.resource_path_override != NULL) {
+	fsb->fsb.resource_path_override =
+		XtNewString(fsb->fsb.resource_path_override);
+    }
+
+    /* Get the context */
+
+    if (fsb->fsb.context == NULL) {
+	fsb->fsb.context = XDPSGetSharedContext(XtDisplay(fsb));
+    }
+
+    if (_XDPSTestComponentInitialized(fsb->fsb.context,
+				      dps_init_bit_fsb, &inited) ==
+	dps_status_unregistered_context) {
+	XDPSRegisterContext(fsb->fsb.context, False);
+    }
+
+    if (!inited) {
+	(void) _XDPSSetComponentInitialized(fsb->fsb.context,
+					    dps_init_bit_fsb);
+	_DPSFDefineFontEnumFunctions(fsb->fsb.context);
+    }
+
+    DPSversion(fsb->fsb.context, 20, version);
+    fsb->fsb.old_server = (atof(version) < 1007);
+
+    /* Initialize non-resource fields */
+
+    fsb->fsb.gstate = 0;
+    fsb->fsb.sampler = fsb->fsb.creator = NULL;
+    fsb->fsb.known_families = NULL;
+    fsb->fsb.family_count = 0;
+    fsb->fsb.currently_previewed = NULL;
+    fsb->fsb.currently_selected_face = NULL;
+    fsb->fsb.currently_selected_family = NULL;
+    fsb->fsb.currently_previewed_blend = NULL;
+    fsb->fsb.currently_selected_blend = NULL;
+    fsb->fsb.currently_previewed_size = 0.0;
+    fsb->fsb.currently_selected_size = 0.0;
+    fsb->fsb.pending_delete_count = 0;
+    fsb->fsb.pending_delete_font = NULL;
+    fsb->fsb.preview_fixed = False;
+    fsb->fsb.current_family_multiple = False;
+    fsb->fsb.current_face_multiple = False;
+    fsb->fsb.current_size_multiple = False;
+    fsb->fsb.blends_changed = False;
+
+    GetFontNames(fsb);
+    CreateChildren(fsb);
+
+    DisplayFontFamilies(fsb);
+    SetUpCurrentSelections(fsb);
+    DesensitizeReset(fsb);
+    if (fsb->fsb.show_sampler) ShowSampler(fsb);
+}
+
+static void FreeFontRec(FontRec *f)
+{
+    BlendDataRec *bd;
+    BlendRec *b, *next_b;
+
+    if (f->blend_data != NULL) {
+	bd = f->blend_data;
+	for (b = bd->blends; b != NULL; b = next_b) {
+	    next_b = b->next;
+	    XtFree((char *) b);
+	}
+	XtFree((char *) bd->internal_break);
+	XtFree((char *) bd->internal_value);
+	XtFree((char *) bd->design_positions);
+	XtFree((char *) bd);
+    }
+    XtFree(f->full_name);
+}
+
+static void FreeFontLists(
+    FontSelectionBoxWidget fsb)
+{
+    FontFamilyRec *ff, *next_ff;
+    FontRec *f, *next_f;
+
+    /* font_name, face_name, family_name, and blend_name are canonical
+       strings and so should not be freed.  The face and blend compound
+       strings were gotten from converters and so should likewise remain. */
+
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = next_ff) {
+	for (f = ff->fonts; f != NULL; f = next_f) {
+	    FreeFontRec(f);
+	    next_f = f->next;
+	    XtFree((char *) f);
+	}
+	next_ff = ff->next;
+	XtFree((char *) ff);
+    }
+    fsb->fsb.known_families = NULL;
+}
+
+static void Destroy(Widget widget)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) widget;
+
+    /* Lots of stuff to destroy! */
+
+    if (fsb->fsb.gstate != 0) XDPSFreeContextGState(fsb->fsb.context,
+						    fsb->fsb.gstate);
+    if (fsb->fsb.preview_string != NULL) XtFree(fsb->fsb.preview_string);
+    if (fsb->fsb.default_resource_path != NULL) {
+	XtFree(fsb->fsb.default_resource_path);
+    }
+    if (fsb->fsb.resource_path_override != NULL) {
+	XtFree(fsb->fsb.resource_path_override);
+    }
+
+    FreeFontLists(fsb);
+}
+
+static void Resize(Widget widget)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) widget;
+
+    XtResizeWidget(fsb->fsb.pane_child, fsb->core.width, fsb->core.height, 0);
+}
+
+/* ARGSUSED */
+
+static Boolean SetValues(
+    Widget old, Widget req, Widget new,
+    ArgList args,
+    Cardinal *num_args)
+{
+    FontSelectionBoxWidget oldfsb = (FontSelectionBoxWidget) old;
+    FontSelectionBoxWidget newfsb = (FontSelectionBoxWidget) new;
+    Boolean refreshLists = False, setSelection = False, do_preview = False;
+    Bool inited;
+
+#define NE(field) newfsb->fsb.field != oldfsb->fsb.field
+#define DONT_CHANGE(field) \
+    if (NE(field)) newfsb->fsb.field = oldfsb->fsb.field;
+
+    DONT_CHANGE(typographic_sort);
+    DONT_CHANGE(pane_child);
+    DONT_CHANGE(preview_child);
+    DONT_CHANGE(panel_child);
+    DONT_CHANGE(family_label_child);
+    DONT_CHANGE(family_multiple_label_child);
+    DONT_CHANGE(family_scrolled_list_child);
+    DONT_CHANGE(face_label_child);
+    DONT_CHANGE(face_multiple_label_child);
+    DONT_CHANGE(face_scrolled_list_child);
+    DONT_CHANGE(size_label_child);
+    DONT_CHANGE(size_text_field_child);
+    DONT_CHANGE(size_option_menu_child);
+    DONT_CHANGE(preview_button_child);
+    DONT_CHANGE(sampler_button_child);
+    DONT_CHANGE(separator_child);
+    DONT_CHANGE(ok_button_child);
+    DONT_CHANGE(apply_button_child);
+    DONT_CHANGE(reset_button_child);
+    DONT_CHANGE(cancel_button_child);
+#undef DONT_CHANGE
+
+    if (newfsb->fsb.size_count > 0 && newfsb->fsb.sizes == NULL) {
+	XtAppWarningMsg(XtWidgetToApplicationContext(new),
+			"setValuesFontBox", "sizeMismatch",
+			"FontSelectionBoxError",
+			"Size count specified but no sizes present",
+			(String *) NULL, (Cardinal *) NULL);
+	newfsb->fsb.size_count = 0;
+    }
+
+    if (newfsb->fsb.size_count < 0) {
+	XtAppWarningMsg(XtWidgetToApplicationContext(new),
+			"setValuesFontBox", "negativeSize",
+			"FontSelectionBoxError",
+			"Size count should not be negative",
+			(String *) NULL, (Cardinal *) NULL);
+	newfsb->fsb.size_count = 0;
+    }
+
+    if (newfsb->fsb.max_pending_deletes <= 0) {
+	XtAppWarningMsg(XtWidgetToApplicationContext(new),
+			"setValuesFontBox", "nonPositivePendingDelete",
+			"FontSelectionBoxError",
+			"Pending delete max must be positive",
+			(String *) NULL, (Cardinal *) NULL);
+	newfsb->fsb.max_pending_deletes = 1;
+    }
+
+    if (NE(preview_string)) {
+	XtFree(oldfsb->fsb.preview_string);
+	newfsb->fsb.preview_string = XtNewString(newfsb->fsb.preview_string);
+	do_preview = True;
+    }
+
+    if (NE(default_resource_path)) {
+	XtFree(oldfsb->fsb.default_resource_path);
+	newfsb->fsb.default_resource_path =
+		XtNewString(newfsb->fsb.default_resource_path);
+	refreshLists = True;
+    }
+
+    if (NE(resource_path_override)) {
+	XtFree(oldfsb->fsb.resource_path_override);
+	newfsb->fsb.resource_path_override =
+		XtNewString(newfsb->fsb.resource_path_override);
+	refreshLists = True;
+    }
+
+    if (newfsb->fsb.undef_unused_fonts) UndefSomeUnusedFonts(newfsb, False);
+
+    if (NE(context)) {
+	if (newfsb->fsb.context == NULL) {
+	    newfsb->fsb.context = XDPSGetSharedContext(XtDisplay(newfsb));
+	} 
+	if (_XDPSTestComponentInitialized(newfsb->fsb.context,
+					  dps_init_bit_fsb, &inited) ==
+	    dps_status_unregistered_context) {
+	    XDPSRegisterContext(newfsb->fsb.context, False);
+	}
+	if (!inited) {
+	    (void) _XDPSSetComponentInitialized(newfsb->fsb.context,
+						dps_init_bit_fsb);
+	    _DPSFDefineFontEnumFunctions(newfsb->fsb.context);
+	}
+    }	
+
+    if (refreshLists) {
+	UndefUnusedFonts((Widget)newfsb);
+	newfsb->fsb.pending_delete_font = NULL;
+	newfsb->fsb.pending_delete_count = 0;
+	FreeFontLists(newfsb);
+	GetFontNames(newfsb);
+	DisplayFontFamilies(newfsb);
+	setSelection = True;
+    }
+
+    if (NE(sizes)) {
+	CreateSizeMenu(newfsb, True);
+	setSelection = True;
+    }
+
+    if (NE(show_sampler)) {
+	if (newfsb->fsb.show_sampler) ShowSampler(newfsb);
+	else XtPopdown(newfsb->fsb.sampler);
+    }
+
+    if (NE(show_sampler_button)) {
+	if (newfsb->fsb.show_sampler_button) {
+	    XtManageChild(newfsb->fsb.sampler_button_child);
+	} else XtUnmanageChild(newfsb->fsb.sampler_button_child);
+    }
+
+    if (NE(font_size)) newfsb->fsb.currently_selected_size = 0.0;
+
+    if (NE(use_font_name) || NE(font_name) || NE(font_family) ||
+	NE(font_face) || NE(font_size) || NE(font_name_multiple) ||
+	NE(font_family_multiple) || NE(font_face_multiple) ||
+	NE(font_size_multiple) || NE(font_blend)) setSelection = True;
+
+    if (setSelection) SetUpCurrentSelections(newfsb);
+    else if (do_preview && newfsb->fsb.preview_on_change) {
+	DoPreview(newfsb, False);
+    }
+
+    if ((NE(font_name) || NE(font_size)) &&
+	XtIsSensitive(newfsb->fsb.reset_button_child)) {
+
+	if ((newfsb->fsb.font_size_multiple ||
+	     newfsb->fsb.font_size == newfsb->fsb.currently_selected_size) &&
+	    (newfsb->fsb.font_name_multiple ||
+	     newfsb->fsb.currently_selected_face == NULL ||
+	     newfsb->fsb.font_name ==
+		    newfsb->fsb.currently_selected_face->font_name)) {
+	    DesensitizeReset(newfsb);
+	}
+    }
+
+    return False;
+#undef NE
+}
+
+/* ARGSUSED */
+
+static XtGeometryResult GeometryManager(
+    Widget w,
+    XtWidgetGeometry *desired, XtWidgetGeometry *allowed)
+{
+#define WANTS(flag) (desired->request_mode & flag)
+
+    if (WANTS(XtCWQueryOnly)) return XtGeometryYes;
+
+    if (WANTS(CWWidth)) w->core.width = desired->width;
+    if (WANTS(CWHeight)) w->core.height = desired->height;
+    if (WANTS(CWX)) w->core.x = desired->x;
+    if (WANTS(CWY)) w->core.y = desired->y;
+    if (WANTS(CWBorderWidth)) {
+	w->core.border_width = desired->border_width;
+    }
+
+    return XtGeometryYes;
+#undef WANTS
+}
+
+static void ChangeManaged(Widget w)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+
+    w->core.width = fsb->composite.children[0]->core.width;
+    w->core.height = fsb->composite.children[0]->core.height;
+}
+
+static void SetFontName(
+    Widget w,
+    String name,
+    Bool name_multiple)
+{
+    XtVaSetValues(w, XtNfontName, name, XtNuseFontName, True,
+		  XtNfontNameMultiple, name_multiple, NULL);
+}
+
+void FSBSetFontName(
+    Widget w,
+    String name,
+    Bool name_multiple)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->fsb_class.set_font_name)
+	    (w, name, name_multiple);
+}
+
+static void SetFontFamilyFace(
+    Widget w,
+    String family, String face,
+    Bool family_multiple, Bool face_multiple)
+{
+    XtVaSetValues(w, XtNfontFamily, family, XtNfontFace, face,
+		  XtNuseFontName, False,
+		  XtNfontFamilyMultiple, family_multiple,
+		  XtNfontFaceMultiple, face_multiple, NULL);
+}
+
+void FSBSetFontFamilyFace(
+    Widget w,
+    String family, String face,
+    Bool family_multiple, Bool face_multiple)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.set_font_family_face)
+	    (w, family, face, family_multiple, face_multiple);
+}
+
+static void SetFontSize(
+    Widget w,
+    double size,
+    Bool size_multiple)
+{
+    int i;
+    Arg args[2];
+
+    union {
+	int i;
+	float f;
+    } kludge;
+
+    kludge.f = size;
+
+    i = 0;
+    if (sizeof(float) > sizeof(XtArgVal)) {
+	XtSetArg(args[i], XtNfontSize, &kludge.f);			i++;
+    } else XtSetArg(args[i], XtNfontSize, kludge.i);			i++;
+    XtSetArg(args[i], XtNfontSizeMultiple, size_multiple);		i++;
+    XtSetValues(w, args, i);
+}
+
+void FSBSetFontSize(
+    Widget w,
+    double size,
+    Bool size_multiple)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->fsb_class.set_font_size)
+	    (w, size, size_multiple);
+}
+
+static void RefreshFontList(Widget w)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+
+    UndefUnusedFonts((Widget)fsb);
+    fsb->fsb.pending_delete_font = NULL;
+    fsb->fsb.pending_delete_count = 0;
+    FreeFontLists(fsb);
+    FreePSResourceStorage(True);
+    GetFontNames(fsb);
+    DisplayFontFamilies(fsb);
+    SetUpCurrentSelections(fsb);
+}
+
+void FSBRefreshFontList(
+    Widget w)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.refresh_font_list) (w);
+}
+
+static void GetFamilyList(
+    Widget w,
+    int *count,
+    String **list)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    String *buf;
+    FontFamilyRec *ff;
+
+    *count = fsb->fsb.family_count;
+    *list = buf = (String *) XtMalloc(*count * sizeof(String));
+    
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	*buf++ = ff->family_name;
+    }
+}
+
+void FSBGetFamilyList(
+    Widget w,
+    int *count,
+    String **list)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.get_family_list) (w, count, list);
+}
+
+static void GetFaceList(
+    Widget w,
+    String family,
+    int *count,
+    String **face_list, String **font_list)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    String *buf1, *buf2;
+    FontFamilyRec *ff;
+    FontRec *f;
+    
+    family = Canonical(family);
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	if (ff->family_name == family) break;
+    }
+
+    if (ff == NULL) {
+	*count = 0;
+	*face_list = *font_list = NULL;
+	return;
+    }
+
+    *count = ff->font_count;
+    *face_list = buf1 = (String *) XtMalloc(*count * sizeof(String));
+    *font_list = buf2 = (String *) XtMalloc(*count * sizeof(String));
+
+    for (f = ff->fonts; f != NULL; f = f->next) {
+	*buf1++ = f->face_name;
+	*buf2++ = f->font_name;
+    }
+}
+
+void FSBGetFaceList(
+    Widget w,
+    String family,
+    int *count_return,
+    String **face_list, String **font_list)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.get_face_list) (w, family, count_return,
+					      face_list, font_list);
+}
+
+void FSBUndefineUnusedFonts(
+    Widget w)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.undef_unused_fonts) (w);
+}
+
+static Boolean DownloadFontName(Widget w, String name)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    FontFamilyRec *ff;
+    FontRec *f;
+    Boolean ret;
+
+    name = Canonical(name);
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == name) {
+		if (!fsb->fsb.get_server_fonts) {
+		    int resident;
+		    _DPSFIsFontResident(fsb->fsb.context, f->font_name,
+					&resident);
+		    if (resident) f->resident = True;
+		}
+		if (f->resident) return True;
+		else {
+		    ret = DownloadFont(fsb, name, fsb->fsb.context,
+				       fsb->fsb.make_fonts_shared);
+		    if (fsb->fsb.make_fonts_shared && ret) f->resident = True;
+		    return ret;
+		}
+	    }
+	}
+    }
+ 
+    return DownloadFont(fsb, name, fsb->fsb.context,
+			fsb->fsb.make_fonts_shared);
+}
+
+Boolean FSBDownloadFontName(
+    Widget w,
+    String name)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    if (name == NULL) return False;
+    return (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.download_font_name) (w, name);
+}
+
+static Boolean MatchFontFace(
+    Widget w,
+    String old_face, String new_family,
+    String *new_face)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    FSBFaceSelectCallbackRec rec;
+    String *faces;
+    int i;
+    FontFamilyRec *ff;
+    FontRec *f;
+    Boolean retVal;
+
+    new_family = Canonical(new_family);
+    old_face = Canonical(old_face);
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	if (ff->family_name == new_family) break;
+    }
+    if (ff == NULL) {
+	*new_face = NULL;
+	return False;
+    }
+
+    faces = (String *) XtMalloc(ff->font_count * sizeof(String));
+    i = 0;
+    for (f = ff->fonts; f != NULL; f = f->next) faces[i++] = f->face_name;
+
+    rec.available_faces = faces;
+    rec.num_available_faces = ff->font_count;
+    rec.current_face = old_face;
+    rec.new_face = NULL;
+
+    i = MatchFaceName(&rec, &retVal);
+    *new_face = faces[i];
+    XtFree((XtPointer) faces);
+    return !retVal;
+}
+
+Boolean FSBMatchFontFace(
+    Widget w,
+    String old_face, String new_family,
+    String *new_face)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    return (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.match_font_face) (w, old_face,
+						new_family, new_face);
+}
+
+static void FontNameToFamilyFaceBlend(
+    Widget w,
+    String font_name,
+    String *family, String *face, String *blend)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+
+    font_name = Canonical(font_name);
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == font_name) {
+		*family = ff->family_name;
+		*face = f->face_name;
+		*blend = NULL;
+		return;
+	    }
+	    if (f->blend_data != NULL) {
+		for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		    if (b->font_name == font_name) {
+			*family = ff->family_name;
+			*face = f->face_name;
+			*blend = b->blend_name;
+			return;
+		    }
+		}
+	    }
+	}
+    }
+
+    *family = NULL;
+    *face = NULL;
+    *blend = NULL;
+}
+
+static void FontNameToFamilyFace(
+    Widget w,
+    String font_name,
+    String *family, String *face)
+{
+    String blend;
+
+    FontNameToFamilyFaceBlend(w, font_name, family, face, &blend);
+}
+
+void FSBFontNameToFamilyFace(
+    Widget w,
+    String font_name,
+    String *family, String *face)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.font_name_to_family_face) (w, font_name,
+							 family, face);
+}
+
+static void FontFamilyFaceBlendToName(
+    Widget w,
+    String family, String face, String blend,
+    String *font_name)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+
+    family = Canonical(family);
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	if (ff->family_name == family) break;
+    }
+    if (ff == NULL) {
+	*font_name = NULL;
+	return;
+    }
+
+    face = Canonical(face);
+    for (f = ff->fonts; f != NULL; f = f->next) {
+	if (f->face_name == face) break;
+    }
+    if (f == NULL) {
+	*font_name = NULL;
+	return;
+    }
+
+    if (blend == NULL) {
+	*font_name = f->font_name;
+	return;
+    }
+    if (f->blend_data == NULL) {
+	*font_name = NULL;
+	return;
+    }
+
+    blend = Canonical(blend);
+    for (b = f->blend_data->blends; b != NULL; b = b->next) {
+	if (b->blend_name == blend) {
+	    *font_name = b->font_name;
+	    return;
+	}
+    }
+    *font_name = NULL;
+}
+
+static void FontFamilyFaceToName(
+    Widget w,
+    String family, String face,
+    String *font_name)
+{
+    FontFamilyFaceBlendToName(w, family, face, NULL, font_name);
+}
+
+void FSBFontFamilyFaceToName(
+    Widget w,
+    String family, String face,
+    String *font_name)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass)
+       XtClass(w))->fsb_class.font_family_face_to_name) (w, family, face,
+							 font_name);
+}
+
+String FSBFindAFM(
+    Widget w,
+    String font_name)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    return (*((FontSelectionBoxWidgetClass) XtClass(w))->
+	    fsb_class.find_afm) (w, font_name);
+}
+
+String FSBFindFontFile(
+    Widget w,
+    String font_name)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    return (*((FontSelectionBoxWidgetClass) XtClass(w))->
+	    fsb_class.find_font_file) (w, font_name);
+}
+
+static void GetTextDimensions(
+    Widget w,
+    String text, String font,
+    double size, double x, double y,
+    float *dx, float *dy, float *left, float *right, float *top, float *bottom)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    int bogusFont;
+
+    _DPSFGetTextDimensions(fsb->fsb.context, text, font, size, x, y,
+			   dx, dy, left, right, top, bottom, &bogusFont);
+}
+
+void FSBGetTextDimensions(
+    Widget w,
+    String text, String font,
+    double size, double x, double y,
+    float *dx, float *dy, float *left, float *right, float *top, float *bottom)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->
+	fsb_class.get_text_dimensions) (w, text, font, size, x, y,
+					dx, dy, left, right, top, bottom);
+}
+
+static void SetFontFamilyFaceBlend(
+    Widget w,
+    String family,
+    String face,
+    String blend,
+    Bool family_multiple,
+    Bool face_multiple)
+{
+    XtVaSetValues(w, XtNfontFamily, family, XtNfontFace, face,
+		  XtNfontBlend, blend, XtNuseFontName, False,
+		  XtNfontFamilyMultiple, family_multiple,
+		  XtNfontFaceMultiple, face_multiple, NULL);
+}
+
+void FSBSetFontFamilyFaceBlend(
+    Widget w,
+    String font_family,
+    String font_face,
+    String font_blend,
+    Bool font_family_multiple,
+    Bool font_face_multiple)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->
+        fsb_class.set_font_family_face_blend) (w, font_family, font_face,
+					       font_blend,
+					       font_family_multiple,
+					       font_face_multiple);
+}
+
+void FSBFontNameToFamilyFaceBlend(
+    Widget w,
+    String font_name,
+    String *family,
+    String *face,
+    String *blend)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->
+        fsb_class.font_name_to_family_face_blend) (w, font_name, family,
+						   face, blend);
+}
+    
+void FSBFontFamilyFaceBlendToName(
+    Widget w,
+    String family,
+    String face,
+    String blend,
+    String *font_name)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->
+        fsb_class.font_family_face_blend_to_name) (w, family, face,
+						   blend, font_name);
+}
+
+static void GetBlendList(
+    Widget w,
+    String name,
+    int *count_return,
+    String **blend_return,
+    String **font_name_return,
+    float **axis_values_return)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    String *buf1, *buf2;
+    float *buf3;
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+    int i;
+
+    name = Canonical(name);
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == name) break;
+	}
+    }
+
+    if (ff == NULL || f == NULL || f->blend_data == NULL) {
+	*count_return = 0;
+	*blend_return = *font_name_return = NULL;
+	*axis_values_return = NULL;
+	return;
+    }
+	
+    *count_return = f->blend_count;
+    *blend_return = buf1 = (String *) XtMalloc(*count_return * sizeof(String));
+    *font_name_return = buf2 =
+	    (String *) XtMalloc(*count_return * sizeof(String));
+    *axis_values_return = buf3 =
+	    (float *) XtMalloc(*count_return * MAX_AXES * sizeof(float));
+
+
+    for (b = f->blend_data->blends; b != NULL; b = b->next) {
+	*buf1++ = b->blend_name;
+	*buf2++ = b->font_name;
+	for (i = 0; i < MAX_AXES; i++) *buf3++ = b->data[i];
+    }
+}
+
+void FSBGetBlendList(
+    Widget w,
+    String name,
+    int *count_return,
+    String **blend_return,
+    String **font_name_return,
+    float **axis_values_return)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->
+        fsb_class.get_blend_list) (w, name, count_return, blend_return,
+				   font_name_return, axis_values_return);
+}
+
+static void GetBlendInfo(
+    Widget w,
+    String name,
+    int *num_axes_return,
+    int *num_designs_return,
+    String **axis_names_return,
+    float **blend_positions_return,
+    int **blend_map_count_return,
+    int **blend_design_coords_return,
+    float **blend_normalized_coords_return)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendDataRec *bd;
+    int i, j;
+    float *fbuf;
+    int *ibuf;
+    String *sbuf;
+    int coords;
+
+    name = Canonical(name);
+    if (fsb->fsb.currently_selected_face->font_name == name) {
+	bd = fsb->fsb.currently_selected_face->blend_data;
+    } else {
+
+	for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	    for (f = ff->fonts; f != NULL; f = f->next) {
+		if (f->font_name == name) goto FOUND_IT;
+	     }
+	}
+	*num_axes_return = *num_designs_return = 0;
+	*axis_names_return = NULL;
+	*blend_positions_return = *blend_normalized_coords_return = NULL;
+	*blend_map_count_return = *blend_design_coords_return = NULL;
+	return;
+
+FOUND_IT:
+	bd = f->blend_data;
+    }
+
+    *num_axes_return = bd->num_axes;
+    *num_designs_return = bd->num_designs;
+
+    *axis_names_return = sbuf =
+	    (String *) XtMalloc(bd->num_axes * sizeof(String));
+    *blend_map_count_return = ibuf =
+	    (int *) XtMalloc(bd->num_axes * sizeof(int));
+    coords = 0;
+    for (i = 0; i < bd->num_axes; i++) {
+	*sbuf++ = bd->name[i];
+	*ibuf++ = bd->internal_points[i] + 2;
+	coords += bd->internal_points[i] + 2;
+    }
+
+    *blend_positions_return = fbuf =
+	    (float *) XtMalloc(bd->num_axes * bd->num_designs * sizeof(float));
+    for (i = 0; i < bd->num_axes * bd->num_designs; i++) {
+	*fbuf++ = bd->design_positions[i];
+    }
+
+    *blend_design_coords_return = ibuf =
+	    (int *) XtMalloc(coords * sizeof(int));
+    *blend_normalized_coords_return = fbuf =
+	    (float *) XtMalloc(coords * sizeof(float));
+
+    for (i = 0; i < bd->num_axes; i++) {
+	*ibuf++ = bd->min[i];
+	*fbuf++ = 0.0;
+	for (j = 0; j < bd->internal_points[i]; j++) {
+	    *ibuf++ = bd->internal_break[i][j];
+	    *fbuf++ = bd->internal_value[i][j];
+	}
+	*ibuf++ = bd->max[i];
+	*fbuf++ = 1.0;
+    }
+}
+
+void FSBGetBlendInfo(
+    Widget w,
+    String name,
+    int *num_axes_return,
+    int *num_designs_return,
+    String **axis_names_return,
+    float **blend_positions_return,
+    int **blend_map_count_return,
+    int **blend_design_coords_return,
+    float **blend_normalized_coords_return)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    (*((FontSelectionBoxWidgetClass) XtClass(w))->
+        fsb_class.get_blend_info) (w, name, num_axes_return,
+				   num_designs_return, axis_names_return,
+				   blend_positions_return,
+				   blend_map_count_return,
+				   blend_design_coords_return,
+				   blend_normalized_coords_return);
+}
+
+static Boolean ChangeBlends(
+    Widget w,
+    String base_name,
+    String blend_name,
+    FSBBlendAction action,
+    int *axis_values,
+    float *axis_percents)
+{
+    FontSelectionBoxWidget fsb = (FontSelectionBoxWidget) w;
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b = NULL, *newb, **lastb;
+    BlendDataRec *bd;
+    String spaceBlend;
+    int val[4];
+    float pct[4];
+    int i;
+
+    base_name = Canonical(base_name);
+    blend_name = Canonical(blend_name);
+
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == base_name) {
+		if ((bd = f->blend_data) == NULL) return False;
+
+		for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		    if (b->blend_name == blend_name) break;
+		}
+		goto FOUND_BASE;
+	    }
+	}
+    }
+    return False;
+
+FOUND_BASE:
+    if (action != FSBDeleteBlend) { 
+	if (axis_values != NULL) {
+	    for (i = 0; i < bd->num_axes; i++) {
+		val[i] = axis_values[i];
+		pct[i] = _FSBNormalize(val[i], bd, i);
+	    }
+	    for (/**/; i < 4; i++) pct[i] = 0.0;
+	} else {
+	    if (axis_percents == NULL) return False;
+	    for (i = 0; i < bd->num_axes; i++) {
+		pct[i] = axis_percents[i];
+		val[i] = _FSBUnnormalize(pct[i], bd, i);
+	    }
+	    for (/**/; i < 4; i++) pct[i] = 0.0;
+	}
+    }
+
+    switch (action) {
+	case FSBAddBlend:
+	    if (b != NULL) return False;
+	    newb = XtNew(BlendRec);
+	    newb->blend_name = blend_name;
+	    newb->CS_blend_name = CS(blend_name, (Widget) fsb);
+
+	    spaceBlend = (char *) XtMalloc(strlen(blend_name) + 4);
+	    spaceBlend[0] = spaceBlend[1] = spaceBlend[2] = ' ';
+	    strcpy(spaceBlend+3, blend_name);
+	    newb->CS_space_blend_name = CS(spaceBlend, (Widget) fsb);
+	    XtFree((XtPointer) spaceBlend);
+
+	    for (i = 0; i < MAX_AXES; i++) newb->data[i] = pct[i];
+	    newb->font_name = _FSBGenFontName(base_name, val, bd);
+
+	    f->blend_count++;
+	    ff->blend_count++;
+
+	    lastb = &bd->blends;
+	    for (b = bd->blends; b != NULL; b = b->next) {
+		if (strcmp(blend_name, b->blend_name) < 0) break;
+		lastb = &b->next;
+	    }
+
+	    newb->next = b;
+	    *lastb = newb;
+	    break;
+
+	case FSBReplaceBlend:
+	    if (b == NULL) return False;
+
+	    for (i = 0; i < MAX_AXES; i++) b->data[i] = pct[i];
+	    b->font_name = _FSBGenFontName(base_name, val, bd);
+	    if (b == fsb->fsb.currently_previewed_blend) DoPreview(fsb, False);
+
+	    break;
+
+	case FSBDeleteBlend:
+	    if (b == NULL) return False;
+
+	    if (bd->blends == b) {
+		bd->blends = b->next;
+	    } else {
+		for (newb = bd->blends; newb->next != b; newb = newb->next) {}
+		newb->next = b->next;
+	    }
+
+	    f->blend_count--;
+	    ff->blend_count--;
+
+	    /* Don't actually delete the blend record, in case it's displayed
+	       in the sampler. */
+	    break;
+    }
+    if (f->in_font_creator) _FSBSetCreatorFamily(fsb->fsb.creator, ff);
+    if (ff == fsb->fsb.currently_selected_family) SetUpFaceList(fsb, ff);
+    fsb->fsb.blends_changed = True;
+    WriteBlends(fsb);
+    return True;
+}
+
+Boolean FSBChangeBlends(
+    Widget w,
+    String base_name,
+    String blend_name,
+    FSBBlendAction action,
+    int *axis_values,
+    float *axis_percents)
+{
+    XtCheckSubclass(w, fontSelectionBoxWidgetClass, NULL);
+
+    return (*((FontSelectionBoxWidgetClass) XtClass(w))->
+	    fsb_class.change_blends) (w, base_name, blend_name, action,
+				    axis_values, axis_percents);
+}
+
+void _FSBSetCurrentFont(
+    FontSelectionBoxWidget fsb,
+    String name)
+{
+    FontFamilyRec *ff;
+    FontRec *f;
+    BlendRec *b;
+    int i, j;
+
+    fsb->fsb.current_family_multiple = False;
+    fsb->fsb.current_face_multiple = False;
+    UnmanageFamilyMultiple(fsb);
+    UnmanageFaceMultiple(fsb);
+
+    name = Canonical(name);
+    i = 1;
+    for (ff = fsb->fsb.known_families; ff != NULL; ff = ff->next) {
+	j = 1;
+	for (f = ff->fonts; f != NULL; f = f->next) {
+	    if (f->font_name == name) {
+		b = NULL;
+		goto FOUND_NAME;
+	    }
+	    j++;
+	    if (f->blend_data != NULL && f->blend_data->blends != NULL) {
+		for (b = f->blend_data->blends; b != NULL; b = b->next) {
+		    if (b->font_name == name) {
+			goto FOUND_NAME;
+		    }
+		    j++;
+		}
+	    }
+
+	}
+	i++;
+    }
+    return;
+FOUND_NAME:
+    SetUpFaceList(fsb, ff);
+    ListSelectPos(fsb->fsb.family_scrolled_list_child, i, False);
+    ListSelectPos(fsb->fsb.face_scrolled_list_child, j, False);
+    fsb->fsb.currently_selected_face = f;
+    fsb->fsb.currently_selected_family = ff;
+    fsb->fsb.currently_selected_blend = b;
+    SensitizeReset(fsb);
+    DoPreview(fsb, False);
+}
+
+float _FSBNormalize(
+    int val,
+    BlendDataRec *bd,
+    int i)
+{
+    int j;
+    int lessBreak, moreBreak;
+    float lessValue, moreValue;
+
+    if (bd->internal_points[i] == 0) {
+	return ((float) (val - bd->min[i])) /
+		((float) (bd->max[i] - bd->min[i]));
+    }
+
+    /* Find the largest breakpoint less than val and the smallest one greater
+       than it */
+
+    lessBreak = bd->min[i];
+    lessValue = 0.0;
+    moreBreak = bd->max[i];
+    moreValue = 1.0;
+
+    for (j = 0; j < bd->internal_points[i]; j++) {
+	if (bd->internal_break[i][j] > lessBreak &&
+	    bd->internal_break[i][j] <= val) {
+	    lessBreak = bd->internal_break[i][j];
+	    lessValue = bd->internal_value[i][j];
+	}
+	if (bd->internal_break[i][j] < moreBreak &&
+	    bd->internal_break[i][j] >= val) {
+	    moreBreak = bd->internal_break[i][j];
+	    moreValue = bd->internal_value[i][j];
+	}
+    }
+
+    if (moreBreak == lessBreak) return moreValue;
+
+    return lessValue + (moreValue - lessValue) *
+	    ((float) (val - lessBreak)) / ((float) (moreBreak - lessBreak));
+}
+
+int _FSBUnnormalize(val, bd, i)
+    float val;
+    BlendDataRec *bd;
+    int i;
+{
+    int j;
+    int lessBreak, moreBreak;
+    float lessValue, moreValue;
+
+    if (bd->internal_points[i] == 0) {
+	return val * (bd->max[i] - bd->min[i]) + bd->min[i] + 0.5;
+    }
+
+    /* Find the largest breakpoint less than val and the smallest one greater
+       than it */
+
+    lessBreak = bd->min[i];
+    lessValue = 0.0;
+    moreBreak = bd->max[i];
+    moreValue = 1.0;
+
+    for (j = 0; j < bd->internal_points[i]; j++) {
+	if (bd->internal_value[i][j] > lessValue &&
+	    bd->internal_value[i][j] <= val) {
+	    lessBreak = bd->internal_break[i][j];
+	    lessValue = bd->internal_value[i][j];
+	}
+	if (bd->internal_value[i][j] < moreBreak &&
+	    bd->internal_value[i][j] >= val) {
+	    moreBreak = bd->internal_break[i][j];
+	    moreValue = bd->internal_value[i][j];
+	}
+    }
+
+    if (moreBreak == lessBreak) return moreBreak;
+
+    return ((float) (val - lessValue)) / ((float) (moreValue - lessValue)) *
+	    (moreBreak - lessBreak) + lessBreak + 0.5;
+}
+
+String _FSBGenFontName(
+    String name,
+    int *val,
+    BlendDataRec *bd)
+{
+    char nameBuf[256];
+    int i;
+    char *ch;
+
+    strcpy(nameBuf, name);
+    ch = nameBuf + strlen(nameBuf);
+
+    for (i = 0; i < bd->num_axes; i++) {
+	sprintf(ch, "_%d_%s", val[i], bd->name[i]);
+	ch = ch + strlen(ch);
+    }
+
+    return Canonical(nameBuf);
+}