/*

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

 * 

 */

#define dbg() fprintf(stderr, "file: %s - XtWidgetToApplicationContext() on line: %d\n", __FILE__, __LINE__);

#include <stdio.h>

#include <ctype.h>

#include <stdlib.h>

#include <string.h>		/* May have to be strings.h on some systems. */

#include <Xm/Xm.h>

#include <Xm/FontSP.h>

#include <Xm/Label.h>

#include <Xm/PushB.h>

#include <Xm/RowColumn.h>

#include <Xm/TextF.h>

#include <Xm/Text.h>

#include <Xm/ToggleB.h>

#include <Xm/MenuShell.h>

#include <Xm/DropDown.h>

#include <Xm/ButtonBox.h>

#include <Xm/ExtP.h>

#include "Xm/XmI.h"

#define NUM_XLFD_DASHES 14

/* max number of fonts that can be returned (CARD16) */

#define TRY_FONTS 	(unsigned int) 65535

#define NUM_BUTTONS	30	/* The MAX number of encoding buttons. */

#define ANY_FAMILY	0	/* Don't change this, without fixing */

				/* ProcessXldfFontData */

#define GET_FONT_SIZE BUFSIZ

#define ALLOC_INC 		100

#define FAMILY_INC 		10

#define WIDGET_LIST_INC 	10

#define POINT_DIVIDE		10

#define DEFAULT_WEIGHT  	("medium")

#define BOLD_WEIGHT     	("bold")

#define DEFAULT_SLANT   	("r")

#define ITALIC_SLANT    	("i")

#define DEFAULT_FIXED_SPACING   ("c")

#define OTHER_FIXED_SPACING 	("m")

#define PROPORTIONAL_SPACING  	("p")

#define STAR_STRING	("*")

#define ANY_ENCODING	("*-*")

#define FAMILY_COLUMNS    20

#define VISIBILE_FAMILIES  11

static short GValidSizes[] = {

    2, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,22,23,24,26,28,36,48,72

};

/*

 * A font may only be scaled in one resolution, not all resolutions. 

 */

#define IsScaled(fsw, fam) (XmFontS_use_scaling((fsw)) &&                     \

			    ((CheckFlag(XmFontS_user_state((fsw)), DPI_75) && \

			      CheckFlag((fam)->state, SCALED_75))          || \

			     (CheckFlag(XmFontS_user_state((fsw)), DPI_100)&& \

			      CheckFlag((fam)->state, SCALED_100))))

/************************************************************

 *       GLOBAL DECLARATIONS

 ************************************************************/

/************************************************************

 *     Private functions - for creating children widgets.

 ************************************************************/

static void CreateChildren(XmFontSelectorWidget, ArgList, Cardinal);

static void CreateTopWidgets(XmFontSelectorWidget, Widget, ArgList, Cardinal);

static void CreateMiddleArea(XmFontSelectorWidget, ArgList, Cardinal);

static void CreateSpacingBox(XmFontSelectorWidget, Widget, ArgList, Cardinal);

static void CreateFontChoiceBox(XmFontSelectorWidget, Widget,ArgList,Cardinal);

static void CreateResolutionBox(XmFontSelectorWidget, Widget,ArgList,Cardinal);

static void CreateFamilyBox(XmFontSelectorWidget, Widget, ArgList, Cardinal);

static void CreateSizesBox(XmFontSelectorWidget, Widget, ArgList, Cardinal);

static void CreateBoldItalicBox(XmFontSelectorWidget,Widget,ArgList, Cardinal);

static void CreateOtherChoiceBox(XmFontSelectorWidget,

				 Widget, ArgList, Cardinal);

/************************************************************

 *     Private functions. 

 ************************************************************/

static void LoadFontData(Widget, FontData **, int *, String **, int *);

static void ProcessXlfdFontData(XmFontSelectorWidget, 

				FontInfo *, FontData *, int);

static void SortOtherFontData(FontInfo *, String *, int);

static void AddToOtherList(char *, String **, int *, int *);

static void SetNonStringData(FontData *), SetFlag(Flag *, Flag, Boolean);

static void StoreString(register String, register String, register int);

static void SetLongFlag(LongFlag *, LongFlag, Boolean);

static void UpdateExistingFamily(FamilyInfo *, FontData *);

static void FillNewFamily(FamilyInfo *, FontData *);

static void SetResolution(XmFontSelectorWidget, FontData *);

static void DisplayCurrentFont(XmFontSelectorWidget, String);

static void UpdateBoldItalic(XmFontSelectorWidget);

static void UpdateFixedProportional(XmFontSelectorWidget);

static void UpdateFamilies(XmFontSelectorWidget);

static void UpdateSizes(XmFontSelectorWidget);

static void SetComboValue(Widget, String), UnsetSiblings(Widget);

static void DisplayUserError(XmFontSelectorWidget, String);

static void SetDisplayedFont(XmFontSelectorWidget, String);

static void AddToXlfdOnlyList(XmFontSelectorWidget, Widget);

static void AddToXlfdSensitiveList(XmFontSelectorWidget, Widget);

static void ChangeMode(XmFontSelectorWidget, Boolean, Boolean);

static void SetOtherList(XmFontSelectorWidget, Boolean);

static void AddToXlfdList(XmFontSelectorWidget, 

			  char *, FontData **, int *, int *);

static Widget CreateEncodingMenu(XmFontSelectorWidget, 

				 Widget, ArgList, Cardinal);

static FontInfo * LoadFontInfo(XmFontSelectorWidget);

static int FindResolution(Widget), CmpStrings(const void *, const void *);

static Boolean CheckFlag(Flag, Flag), CheckLongFlag(LongFlag, LongFlag);

static Boolean FillData(XmFontSelectorWidget, FontData *, char *);

static Boolean IsXlfdFont(register char *);

static Boolean CheckEncoding(XmFontSelectorWidget, FamilyInfo *);

static FamilyInfo *FindFamily(register XrmQuark, FamilyInfo *, int);

static String BuildFontString(XmFontSelectorWidget, FontData *, String, int);

static LongFlag SizeMapping(short);

/************************************************************

 *  Callbacks

 ************************************************************/

static void ToggleMiddlePane(Widget, XtPointer, XtPointer);

static void ToggleNameWindow(Widget, XtPointer, XtPointer);

static void FamilyChanged(Widget, XtPointer, XtPointer);

static void SizeChanged(Widget, XtPointer, XtPointer);

static void ChangeEncoding(Widget, XtPointer, XtPointer);

static void ToggleScaling(Widget, XtPointer, XtPointer);

static void ToggleBold(Widget, XtPointer, XtPointer);

static void ToggleItalic(Widget, XtPointer, XtPointer);

static void Toggle75DPI(Widget, XtPointer, XtPointer);

static void Toggle100DPI(Widget, XtPointer, XtPointer);

static void ToggleBothDPI(Widget, XtPointer, XtPointer);

static void ToggleProportional(Widget, XtPointer, XtPointer);

static void ToggleFixed(Widget, XtPointer, XtPointer);

static void ToggleBothSpacing(Widget, XtPointer, XtPointer);

static void XlfdMode(Widget, XtPointer, XtPointer);

static void OtherMode(Widget, XtPointer, XtPointer);

static void RemoveUserError(Widget, XtPointer, XtPointer);

/************************************************************

 *  Semi-Public functions

 ************************************************************/

static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal *);

static void GetValuesHook(Widget, ArgList, Cardinal *);

static void Destroy(Widget);

static void Initialize(Widget, Widget, ArgList, Cardinal*);

static void ClassPartInitialize(WidgetClass w_class);

static void ClassInitialize();

/*  Resource definitions for Subclasses of Primitive */

#define SAMPLE \

("abcdefghijklmonpqrstuvwxyz\n\

ABCDEFGHIJKLMONPQRSTUVWXYZ\n\

1234567890\n!@#$%^&*()")

/************************************************************

 *       STATIC DECLARATIONS

 ************************************************************/

/*

 * This table is the list of resolutions of fonts that are supported.

 * most machines have only 75 and 100 dpi fonts, so we only find which

 * of those we are closest to with FindResolution().

 */

static int resolutions[] = { 75, 100 };

static XtResource resources[] =

{

  {

    XmNspacing, XmCSpacing, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.internal_bw),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNseparatorOn, XmCSeparatorOn, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedRec, paned.separator_on),

    XmRImmediate, (XtPointer) True

  },

  {

    XmNmarginHeight, XmCMargin, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.margin_height),

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNcurrentFont, XmCString, XmRString,

    sizeof(String), XtOffsetOf(XmFontSelectorRec, fs.current_font),

    XmRImmediate, (XtPointer)NULL

  },

  {

    XmNshowFontName, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmFontSelectorRec, fs.show_font_name),

    XmRImmediate, (XtPointer) False

  },

  {

    XmNuseScaling, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmFontSelectorRec, fs.use_scaling),

    XmRImmediate, (XtPointer) True

  },

  {

    XmNtextRows, XmCTextRows, XmRDimension,

    sizeof(Dimension), XtOffsetOf(XmFontSelectorRec, fs.text_rows),

    XmRImmediate, (XtPointer) 8

  },

  {

    XmNvalueChangedCallback, XmCCallback, XmRCallback,

    sizeof(XtCallbackList), XtOffsetOf(XmFontSelectorRec, fs.font_changed_callback),

    XmRImmediate, (XtPointer) NULL

  },

  {

    XmNsampleText, XmCSampleText, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.sample_text),

    XmRString, (XtPointer) SAMPLE

  },

  {

    XmNanyString, XmCAnyString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.any),

    XmRString, (XtPointer) "Any"

  },

  {

    XmNanyLowerString, XmCAnyLowerString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.lower_any),

    XmRString, (XtPointer) "any"

  },

  {

    XmNfamilyString, XmCFamilyString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.family),

    XmRString, (XtPointer) "Family"

  },

  {

    XmNsizeString, XmCSizeString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.size),

    XmRString, (XtPointer) "Size"

  },

  {

    XmNboldString, XmCBoldString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.bold),

    XmRString, (XtPointer) "Bold"

  },

  {

    XmNitalicString, XmCItalicString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.italic),

    XmRString, (XtPointer) "Italic"

  },

  {

      XmNoptionString, XmCOptionString, XmRXmString,

      sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.option),

      XmRString, (XtPointer) "Options..."

  },

  {

    XmNbothString, XmCBothString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.both),

    XmRString, (XtPointer) "Both"

  },

  {

    XmNmonoSpaceString, XmCMonoSpaceString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.mono_space),

    XmRString, (XtPointer) "Fixed Width Fonts"

  },

  {

    XmNpropSpaceString, XmCPropSpaceString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.prop_space),

    XmRString, (XtPointer) "Proportional Fonts"

  },

  {

    XmNotherString, XmCOtherString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.other_font),

    XmRString, (XtPointer) "Other Fonts"

  },

  {

    XmNxlfdString, XmCXlfdSpaceString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.xlfd),

    XmRString, (XtPointer) "Xlfd Fonts"

  },

  {

    XmN75DPIstring, XmC75DPIString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.dpi_75),

    XmRString, (XtPointer) "75 dpi"

  },

  {

    XmN100DPIstring, XmC100DPIString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.dpi_100),

    XmRString, (XtPointer) "100 dpi"

  },

  {

    XmNscalingString, XmCScalingString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.scaling),

    XmRString, (XtPointer) "Use Font Scaling"

    },

  {

    XmNshowNameString, XmCShowNameString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.show_name),

    XmRString, (XtPointer) "Show Font Name"

  },

    /*

     * Stuff to set the valid charset/encoding pairs.

     */

  {

    XmNencodingString, XmCEncodingString, XmRXmString,

    sizeof(XmString), XtOffsetOf(XmFontSelectorRec, fs.strings.encoding_only),

    XmRString, (XtPointer) "Encoding"

  },

    /*

     * NOTE: This resource value must end in a comma because the resource

     *       converter is broken in Motif1.1.4.

     */

  {

    XmNencodingList, XmCEncodingList, XmRStringTable,

    sizeof(String *), XtOffsetOf(XmFontSelectorRec, fs.strings.encoding_list),

    XmRString, (XtPointer) "iso8859-1,"

  },

  {

    XmNdefaultEncodingString, XmCDefaultEncodingString, XmRString,

    sizeof(String), XtOffsetOf(XmFontSelectorRec, fs.encoding), 

    XmRString, (XtPointer) "iso8859-1"

  }

};

static XmSyntheticResource syn_resources[] =

{

  {

    XmNspacing, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.internal_bw),

    _XmFromPanedPixels, (XmImportProc) _XmToPanedPixels

  },

  {

    XmNmarginHeight, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.margin_height),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  }

};

static XtResource subresources[] =

{

  {

    XmNshowSash, XmCShowSash, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedConstraintsRec, paned.show_sash),

    XmRImmediate, (XtPointer) False

  }

};

#define SuperClass ((ConstraintWidgetClass) &xmPanedClassRec)

XmFontSelectorClassRec xmFontSelectorClassRec = {

   {

/* core class fields */

    /* superclass         */   (WidgetClass) SuperClass,

    /* class name         */   "XmFontSelector",

    /* size               */   sizeof(XmFontSelectorRec),

    /* class_initialize   */   ClassInitialize,

    /* class_part init    */   ClassPartInitialize,

    /* class_inited       */   FALSE,

    /* initialize         */   Initialize,

    /* initialize_hook    */   NULL,

    /* realize            */   XtInheritRealize,

    /* actions            */   NULL,

    /* num_actions        */   0,

    /* resources          */   (XtResourceList)resources,

    /* resource_count     */   XtNumber(resources),

    /* xrm_class          */   NULLQUARK,

    /* compress_motion    */   TRUE,

    /* compress_exposure  */   TRUE,

    /* compress_enterleave*/   TRUE,

    /* visible_interest   */   FALSE,

    /* destroy            */   Destroy,

    /* resize             */   XtInheritResize,

    /* expose             */   NULL,

    /* set_values         */   SetValues,

    /* set_values_hook    */   NULL,

    /* set_values_almost  */   XtInheritSetValuesAlmost,

    /* get_values_hook    */   GetValuesHook, 

    /* accept_focus       */   NULL,

    /* version            */   XtVersion,

    /* callback_private   */   NULL,

    /* tm_table           */   XtInheritTranslations,

    /* query_geometry	  */   XtInheritQueryGeometry,

    /* display_accelerator*/   XtInheritDisplayAccelerator,

    /* extension          */   NULL

   }, {

/* composite class fields */

    /* geometry_manager   */   XtInheritGeometryManager,

    /* change_managed     */   XtInheritChangeManaged,

    /* insert_child       */   XtInheritInsertChild,

    /* delete_child       */   XtInheritDeleteChild,

    /* extension          */   NULL

   }, {

/* constraint class fields */

    /* subresources       */   subresources,

    /* subresource_count  */   XtNumber(subresources),

    /* constraint_size    */   sizeof(XmFontSelectorConstraintsRec),

    /* initialize         */   NULL,

    /* destroy            */   NULL,

    /* set_values         */   NULL,

    /* extension          */   NULL

   }, {

/* manager_class fields   */

      XtInheritTranslations,                    /* translations           */

      syn_resources,	                        /* get resources          */

      XtNumber(syn_resources),    		/* num get_resources      */

      NULL,                			/* get_cont_resources     */

      0,				        /* num_get_cont_resources */

      XmInheritParentProcess,                   /* parent_process         */

      NULL,                                     /* extension              */

  }, {

      /* paned_class fields */

      NULL,                                     /* extension                 */

  }, {

      /* font selector class fields */

      NULL,                                     /* extension                 */

  }

};

WidgetClass xmFontSelectorWidgetClass = (WidgetClass) &xmFontSelectorClassRec;

/***********************************************************

 *

 * Private Functions.

 *

 ************************************************************/

/*	Function Name: LoadFontInfo

 *	Description: Loads the font information from the current screen.

 *	Arguments: fsw - the font selector widget.

 *	Returns: the font information.

 */

static FontInfo *

LoadFontInfo(XmFontSelectorWidget fsw)

{

    FontInfo *font_info = (FontInfo *) XtMalloc(sizeof(FontInfo));

    FontData *xlfd_font_data;

    String *other_fonts;

    int xlfd_num_fonts, other_num_fonts;

    font_info->resolution = FindResolution((Widget) fsw);

    LoadFontData((Widget) fsw, &xlfd_font_data, &xlfd_num_fonts,

		 &other_fonts, &other_num_fonts);

    ProcessXlfdFontData(fsw, font_info, xlfd_font_data, xlfd_num_fonts);

    SortOtherFontData(font_info, other_fonts, other_num_fonts);

    return(font_info);

}

/*	Function Name: LoadFontData

 *	Description: Loads the font data from the X Server, sorts it into

 *                   xlfd and non xlfd fonts, and sorts out the xlfd info.

 *	Arguments: w - any widget on the screen.

 * RETURNED        xlfd_data, num_xlfd - The xlfd font data.

 * RETURNED        other_fonts, num_other - The list of non xlfd fonts.

 *	Returns: none.

 */

static void

LoadFontData(Widget w, FontData **xlfd_data, int *num_xlfd,

	     String **other_fonts, int *num_other)

{

    XmFontSelectorWidget fsw = (XmFontSelectorWidget) w;

    char ** fonts, **ptr;

    int i, num, xlfd_alloc, other_alloc;

    *xlfd_data = NULL;

    *other_fonts = NULL;

    *num_xlfd = *num_other = xlfd_alloc = other_alloc = 0;

    fonts = XListFonts(XtDisplay(w), "*", TRY_FONTS, &num);

    /*

     * Loop the all the fonts and add each one to the proper list.

     */

    if (fonts != NULL)  {

	for (ptr = fonts, i = 0; i < num; i++, ptr++) {

	    if (IsXlfdFont(*ptr)) 

		AddToXlfdList(fsw, *ptr, xlfd_data, num_xlfd, &xlfd_alloc);

	    else 

		AddToOtherList(*ptr, other_fonts, num_other, &other_alloc);

	}

	XFreeFontNames(fonts);

    }

}

/*	Function Name: ProcessXlfdFontData

 *	Description: Processes the Xlfd data, to come up with lists

 *                   of various attributes.

 *	Arguments: fsw - The Font Selector Widget.

 *                 font_info - the font information structure.

 *                 data, num - the xlfd data.

 *	Returns: none.

 *

 * This takes the raw XLFD data and builds lists of families and

 * sizes, and stores all the information in the font_info structure.

 */

static void

ProcessXlfdFontData(XmFontSelectorWidget fsw,

		    FontInfo *font_info, FontData *data, int num_data)

{

    int num, alloc, i;

    FamilyInfo *any_fam, *fam = NULL;

    FontData *top = data;

    String temp;

    /*

     * Leave space for the any family, filled in at the end of the function.

     * 

     * NOTE:  This assumes that (ANY_FAMILY == 0)

     */

    num = 1;		

    alloc = FAMILY_INC;

    fam = (FamilyInfo *) XtMalloc(sizeof(FamilyInfo) * alloc);

    fam->nameq = NULLQUARK;	/* Don't use this family yet. */

    /*

     * Set up the "Any" family.

     */

    for (i = 0; i < num_data; i++, data++) {

	register FamilyInfo *cur_family = FindFamily(data->familyq, fam, num);

	if (cur_family == NULL) {

	    if ( num >= alloc ) {

		alloc += FAMILY_INC;

		fam = (FamilyInfo *) XtRealloc((XtPointer) fam,

					       sizeof(FamilyInfo) * alloc);

	    }

	    FillNewFamily(fam + num, data);

	    num++;

	}

	else {

	    UpdateExistingFamily(cur_family, data);

	}

    }

    font_info->family_info = fam;

    font_info->num_families = num;

    any_fam = fam + ANY_FAMILY;

    temp = _XmGetMBStringFromXmString(ANY_STRING(fsw));

    any_fam->nameq = XrmStringToQuark(temp);

    XtFree(temp);

    any_fam->bold_nameq = XrmStringToQuark(BOLD_WEIGHT);

    any_fam->medium_nameq = XrmStringToQuark(DEFAULT_WEIGHT);

    any_fam->upright_nameq = XrmStringToQuark(DEFAULT_SLANT);

    any_fam->italic_nameq = XrmStringToQuark(ITALIC_SLANT);

    strcpy(any_fam->fixed_spacing, DEFAULT_FIXED_SPACING);

    any_fam->state = (Flag) 0;

    any_fam->sizes_75 = any_fam->sizes_100 = (LongFlag) 0;

    for (i = 1, fam++; i < num; i++, fam++) { 

	any_fam->sizes_75 |= fam->sizes_75;

	any_fam->sizes_100 |= fam->sizes_100;

	any_fam->state |= fam->state;

    }

    any_fam->encodings = NULL;

    any_fam->encoding_alloc = 0;

    XtFree((XtPointer) top);

}

/*	Function Name: SortOtherFonts

 *	Description: Sorts the list of other fonts alphabetically

 *                   and stuffs them into the font data structure.

 *	Arguments: font_info - the font information.

 *                 list, num - the list of fonts.

 *	Returns: none

 */

static void 

SortOtherFontData(FontInfo *font_info, String *list, int num)

{

    register int i = 0;

    qsort((void *) list, num, sizeof(String), CmpStrings);

    /*

     * Remove duplicates.

     */

    while (i < (num - 1)) {

	if (streq(list[i], list[i+1])) {

	    register int j;

	    register String *ptr;

	    XtFree((char*)list[i]);

	    ptr = list + i;

	    j = i;

	    while ( ++j < num) {

		ptr[0] = ptr[1];

		ptr++;

	    }

	    num--;	/*Something has been removed, decrement count*/

	}

	else

	    i++;

    }

    font_info->others = list;

    font_info->num_others = num;

}

/*	Function Name: CmpStrings

 *	Description: Compares two strings.

 *	Arguments: p1, p2 - two string pointers.

 *	Returns: none

 */

static int

CmpStrings(const void * p1, const void *p2)

{

    String *s1 = (String *) p1;

    String *s2 = (String *) p2;

    return(strcmp(*s1, *s2));

}

/*	Function Name: FindResolution

 *	Description: Finds the closest resolution

 *	Arguments: w - any widget on the proper screen.

 *	Returns: the closest allowable resolution to the real resolution.

 */

static int

FindResolution(Widget w)

{

    Screen *screen = XtScreen(w);

    register int i, xres, yres, min, pref;

    /*

     * there are 2.54 centimeters to an inch; so there are 25.4 millimeters.

     *

     *     dpi = N pixels / (M millimeters / (25.4 millimeters / 1 inch))

     *         = N pixels / (M inch / 25.4)

     *         = N * 25.4 pixels / M inch

     *

     *         Or in integer arithmitic

     *

     *         = (254 * N pixels / M inch + 5) / 10

     */

    /* This will get us the true pixels / inch.  That is probably

       not what we want */

    xres = (254 * WidthOfScreen(screen) / WidthMMOfScreen(screen) + 5) / 10;

    yres = (254 * HeightOfScreen(screen) / HeightMMOfScreen(screen) + 5) / 10;

    xres *= xres;

    yres *= yres;

    /*

     * Find the closest resolution by using a difference of squares.

     */

    min = 32000;

    pref = resolutions[0];	/* We have to have some default. */

    for (i = 0; i < XtNumber(resolutions); i++) {

	int diffx = (xres - resolutions[i] * resolutions[i]);

	int diffy = (yres - resolutions[i] * resolutions[i]);

	int tdiff;		/* the total difference. */

	/*

	 * Square 'em.

	 */

	tdiff = (diffx * diffx) + (diffy * diffy);

	if (min > tdiff) {

	    pref = resolutions[i];

	    min = tdiff;

	}

    }

    return(pref);

}

/*	Function Name: IsXlfdFont

 *	Description: Returns True if this is an LXFD font.

 *	Arguments: str - the font name to check.

 *	Returns: none.

 */

static Boolean

IsXlfdFont(register char * str)

{

    register int num_dashes = 0;

    register char c;

    for ( ; (c = *str) != '\0'; str++) {

	if (c == '-')

	    num_dashes++;

    }

    return(num_dashes == NUM_XLFD_DASHES);

}

/*	Function Name: AddToXlfdList

 *	Description: Adds a font to the list of xlfd fonts.

 *	Arguments: name - name of the font.

 *                 list, num - the list of xlfd fonts to add it to.

 *                 alloc - the number of allocated slots.

 *	Returns: none.

 */

static void

AddToXlfdList(XmFontSelectorWidget fsw,

	      char *name, FontData **list, int *num, int *alloc)

{

    FontData *current;

    if (*num >= *alloc) {

	*alloc += ALLOC_INC;

	*list = (FontData *) XtRealloc((XtPointer) *list, 

				       sizeof(FontData) * *alloc);

    }

    current = (*list) + *num;

    /* 

     * If filling the data succeeded, then accept this name, otherwise

     * just ignore it. 

     */

    if (FillData(fsw, current, name)) 

	(*num)++;

}

/*	Function Name: AddToOtherList

 *	Description: Adds a font to the list of other fonts.

 *	Arguments: name - name of the font.

 *                 list, num - the list of other fonts to add it to.

 *                 alloc - the number of allocated slots.

 *	Returns: none.

 */

static void

AddToOtherList(char *name, String **list, int *num, int *alloc)

{

    if (*num >= *alloc) {

	*alloc += ALLOC_INC;

	*list = (String *) XtRealloc((XtPointer) *list, 

				     sizeof(String) * *alloc);

    }

    (*list)[(*num)++] = XtNewString(name);

}

/*	Function Name: FillData(fsw, current, name); 

 *	Description: Fills the current font data from an xlfd name.

 *	Arguments: fsw - The font selector widget.

 *                 current - the font data structure to fill.

 *                 name - an xlfd name of a font.

 *	Returns: False on failure.

 * 

 * This name may have NOT *'s in it.

 */

#define GET_NEXT_FIELD(ptr)                             \

     if (((ptr) = (char *) strchr((ptr), '-')) == NULL) \

	 return(False);                                 \

     (ptr)++	/* skip hyphen */                       \

static Boolean

FillData(XmFontSelectorWidget fsw, FontData *current, char *name)

{

    char *ptr = name;

    char temp[BUFSIZ];

    current->state = 0;		/* Initialize value. */

    GET_NEXT_FIELD(ptr);	/* ptr == Foundry */

    GET_NEXT_FIELD(ptr);	/* ptr == Family */

    StoreString(ptr, temp, BUFSIZ - 1);

    if (streq(temp, STAR_STRING)) { 

	String str = _XmGetMBStringFromXmString(ANY_STRING(fsw));

	strcpy(temp, str);

	XtFree((XtPointer) str);

    }

    current->familyq = XrmStringToQuark(temp);

    GET_NEXT_FIELD(ptr);	/* ptr == Weight */

    StoreString(ptr, temp, BUFSIZ - 1);

    current->weightq = XrmStringToQuark(temp);

    GET_NEXT_FIELD(ptr);	/* ptr == Slant */

    StoreString(ptr, current->slant, SLANT_LEN);

    GET_NEXT_FIELD(ptr);	/* ptr == SetWidth_Name */

    GET_NEXT_FIELD(ptr);	/* ptr == Add_Style_Name */

    GET_NEXT_FIELD(ptr);	/* ptr == Pixel Size */

    GET_NEXT_FIELD(ptr);	/* ptr == Point Size */

    StoreString(ptr, temp, BUFSIZ - 1);

    /*

     * the string '*' will default to 0 which is exactly what I want.

     */

    current->point_size = (short) atoi(temp);

    GET_NEXT_FIELD(ptr);	/* ptr == Resolution X */

    StoreString(ptr, temp, BUFSIZ - 1);

    /*

     * the string '*' will default to 0 which is exactly what I want.

     */

    current->resolution_x = (short) atoi(temp);