TechNote (Archived)

Adding Type 1 fonts to FrameMaker (6.0 on UNIX)

What's covered

Adding fonts

Making the fonts available tothe equations palette, printer, and Acrobat Distiller

Installing and reencoding multiple fonts: a sample script

This document explains how to add Type 1 fonts to FrameMaker 6.0 in UNIX and how to make sure that the added fonts are available to the equations palette, printer, and Adobe Acrobat Distiller. For information about fonts included with FrameMaker 6.0, see document 325333 , "Fonts Included with FrameMaker 6.0."

In this document, the following terms are used:

-- "$FMHOME" represents the directory in which FrameMaker is installed.

-- "${HOME}" represents your home directory.

-- "/cdrom" represents the CD-ROM mount point.

-- "FrameMaker" refers to a FrameMaker product: FrameMaker, FrameMaker+SGML, or FrameViewer.

The procedures below involve changing your FrameMaker system configuration, so make sure to back up your system first.

Adding fonts

You can add fonts from any vendor if they are compatible with the Adobe Type 1 format. You install fonts either by creating a PostScript resource file or by editing the FrameMaker fontlist file. Procedures for both methods appear below. Generally, for an ordinary font that has only bold and italic styles, you can create a PostScript resource file. A more complex font with multiple variations or weights usually requires editing the FrameMaker fontlist file.

UNIX font filetypes

In UNIX, FrameMaker uses *.afm (Adobe Font Metrics) and *.pfa (Printer Font ASCII) font files, which are in ASCII format. (The *.afm files are the font metric files, and the *.pfa files are the font outline files.) You must obtain and install both the *.afm and *.pfa files for each style of the font. For example, the Tekton font contains four styles: Tekton, Tekton Bold, Tekton Bold Oblique, and Tekton Oblique. To use all styles of the Tekton font, you need the *.afm and *.pfa files for each style, or a total of eight files.

Obtaining *.afm and *.pfa font files

*.afm files are often not included in promotional font packages or fonts for Windows or Mac OS. For more information about the availability of *.afm files, contact the font vendor.

Most Type 1 fonts include *.pfb (Printer Font Binary) files, which are used in Windows and Mac OS. If you don't have the *.pfa files, you may be able to convert the *.pfb files to *.pfa files by using the conversion tools fmAdobePCFont and fmAdobeMacFont, which are in the $FMHOME/bin directory. (If you have the Adobe Type Installer [ATI], you can use the *.pfb files in place of *.pfa files; ATI automatically re-encodes them to ASCII format. For details about ATI, see "Creating a PostScript resource file" below.) For example, to convert the *.pfb file for Tekton regular, run this command:

-- For a Windows font:

$FMHOME/bin/fmAdobePCFont TKRG____.PFB Tekton.pfa

-- For a Mac OS font:

Note:Mac OS fonts have the font outline files encoded as the resource fork of the font file. You must extract the font outline data from the resource fork and then convert the font outline to ASCII format. Contact the font vendor if you need help.

$FMHOME/bin/fmAdobeMacFont Tekto Tekton.pfa

If you are unsure which types of font files are in a font package, contact the font vendor.

The font filenames may not fully reflect a font's name. For example, the Tekton font family filenames may be as listed in the following table.

UNIX	Windows	Mac OS
Tekton.afmTekton.pfaTekton-Bold.afmTekton-Bold.pfaTekton-BoldOblique.afmTekton-BoldOblique.pfaTekton-Oblique.afmTekton-Oblique.pfa	TKRG____.AFMTKRG____.INFTKRG____.PFBTKRG____.PFMTKB_____.AFMTKB_____.INFTKB_____.PFBTKB_____.PFMTKBO____.AFMTKBO____.INFTKBO____.PFBTKBO____.PFMTKO_____.AFMTKO_____.INFTKO_____.PFBTKO_____.PFM	TektoTekto.AFMTektoBolTektoBol.AFMTektoBolOblTektoBolObl.AFMTektoOblTektoObl.AFM

Creating a PostScript resource file

When starting, FrameMaker searches for PostScript resource (PSres.upr) files. A PostScript resource file contains statements detailing the directories that contain the *.afm and *.pfa files, and which fonts belong to the same font family. The procedure below explains how to create a PostScript resource file to add fonts manually to the system. Also, a sample shell script appears at the end of this document to help you install multiple fonts. The script is an automated version of the procedure below.

The procedure relies on a system utility (makepsres or mkpsres) to generate PostScript resource files. On Sun Solaris, the makepsres utility is in the /usr/openwin/bin directory.

After you add fonts, you can share them by exporting the directory mount point where the fonts are installed, but remember to update your PSRESOURCEPATH environment variable to reflect the available font paths. Also, after you install Type 1 fonts for use with FrameMaker, you needn't update the X server font path.

To create a PostScript resource file:

Note: In these steps, we use Tekton regular in the examples.

1. Create a directory for the fonts, and then change to it. For example,

mkdir $FMHOME/fontset123
cd $FMHOME/fontset123

2. Unpack the font files.

3. Find the full font name stored in the *.afm file by running one of the following commands:

-- For a Windows or UNIX *.afm file:

egrep FontName TKRG____.AFM

-- For a Mac OS *.afm file:

tr '\r' '\n' < Tekto.AFM | egrep FontName

4. Create a .font directory using the full font name you found in step 3. For example,

mkdir -p fonts/Tekton.font

5. Move the *.afm file to the new directory, modifying the filename to reflect the full font name. For example,

mv TKRG____.AFM fonts/Tekton.font/Tekton.afm

6. Move the *.pfa file to the new directory, modifying the filename to reflect the full font name. For example,

mv TKRG____.PFA fonts/Tekton.font/Tekton.pfa

7. Repeat steps 3-6 for each additional style of the font (for example, Tekton Oblique, Tekton Bold, and Tekton Bold Oblique).

8. Create a PostScript resource file:

makepsres -d -o PSres.upr fonts

9. Update the PSRESOURCEPATH environment variable to access this new PostScript resource directory:

In Korn shell or Bourne shell:

PSRESOURCEPATH=$FMHOME/fontset123:: ; export PSRESOURCEPATH

In C shell:

setenv PSRESOURCEPATH "$FMHOME/fontset123::"

10. Start FrameMaker.

Note: The PSRESOURCEPATH environment variable should always contain two colons (::) to ensure that the default search path is included. To permanently setthis environment variable, insert the line from step 9 into startup shell scripts, such as the env.sh and env.csh FrameMaker environment scripts in the $FMHOME/fminit directory, or your .profile (Korn shell or Bourne shell) or .cshrc (C shell) startup file in your ${HOME} directory.

FrameMaker 5.5.3 and earlier include the Adobe Type On Call 4.0 or 4.1 CD, which includes the Adobe Type Installer (ATI). ATI performs the same procedure described above, but automatically. You can also use ATI to install, manage, download (to a PostScript printer), and remove fonts. Be aware, however, that ATI is no longer distributed or supported. ATI for UNIX was certified to run on Solaris 2.4 on Sun Sparc workstations, and IRIX 5.3 on Silicon Graphics MIPS workstations. It may behave unexpectedly on a later system.

Editing the FrameMaker fontlist file

When you install FrameMaker, it creates a fontlist file by making a soft link from the specific font set file. (For example, with the LaserWriter Plus font set, the fontlist file is soft linked to the fontlist.lwp file.) The fontlist file contains statements describing font files and font properties, such as sizes, families, variations, weights, and angles. You can modify this file to control mappings of additional fonts that you install. The statements also determine available selections in the Paragraph Designer and the Character Designer. If you need to describe unusual angles, weights, variations, or descriptions for these fonts, you must manually add statements for them to the fontlist file. (If you add font sets by editing the fontlist file, errors can occur.)

To edit the FrameMaker fontlist file:

1. Copy the *.afm and *.pfa files into the $FMHOME/fminit/fontdir directory.

2. Find the full font name stored in the *.afm file by running one of the following commands:

-- For a Windows or UNIX *.afm file

egrep FontName TKRG____.AFM

-- For a Mac OS *.afm file

tr '\r' '\n' < Tekto.AFM | egrep FontName

3. Open one of the following fontlist files in a text editor:

-- If you want the fonts to be accessible to all FrameMaker users, open the fontlist file that's in the FrameMaker installation directory, $FMHOME/fminit/fontdir.

-- If you want the fonts to be accessible to you only, copy the fontlist file into the ${HOME}/fminit/fontdir directory, and then open that copy.

4. Add font statements according to the guidelines that follow these steps.

5. Save changes, and close the file.

Guidelines for font statements

Use the following guidelines to add font statements to the FrameMaker fontlist file.

Note: Each font statement starts with a font property word (such as Size or Family) and must have at least one space before the closing angle bracket (>) and between each entry.

-- Size statements

The <Size > statements define the entries in the Font Size menus, and the <DefaultSize > statement defines the default point size. You can have multiple <Size > statements but only one <DefaultSize > statement. For example,

To add a font size to the Size pop-up menu, add a <Size > statement, making sure to maintain the order of the statements. For example, to add 16 points to the menu, add the <Size 16 pt > statement between the <Size 14 pt > and <Size 18 pt >statements.

Some fonts include bitmap versions at particular point sizes for better appearance onscreen. If a bitmap version is available in a size specified for text in a document, FrameMaker uses the bitmap version to display the text. (The fonts included with FrameMaker have bitmap versions in sizes 10, 12, 14, 18, and 24.) FrameMaker uses the appropriate *.afm, *.pfa, and *.bfont (bitmapped) font files to display and print the font. If no *.bfont file exists for a particular size, FrameMaker uses the corresponding outline font or the font information for the next smaller size and then scales the font to the size you specify.

-- Family statements

The Family statements usually appear after the Size statements.They control the handling of some fonts in FrameMaker. For example,

Add a <Family > statement for each font family that is copied into the fminit/fontdir directory.

The <DefaultFamily >statement names the font family that FrameMaker uses when no other family has been assigned to text. If you want one of the new font families to be the default, change the <DefaultFamily > statement so that it lists the appropriate font family. (The <DefaultFamily > statement doesn't control the fonts used when you open a new blank document. For information about changing the fonts in a new blank document, see chapter 12, "Templates," in the FrameMaker 6.0 user guide.)

The <NonText > statement identifies font families that don't contain alphanumeric characters and should be ignored by the Spelling Checker. Add a non-text statement for such fonts.

The <FamilyAlias > statement may be used to declare an alternate Family name for a PostScript font family. This alternate Family name may be necessary when reusing fonts that originated from a different system and have a similar but different name.

Note: Don't edit the <MathFamily > and <FrameFamily > statements because FrameMaker uses them to generate special math and text symbols.

-- Variation statements

Each <Variation >statement describes a choice in the Variation pop-up menu, and the <DefaultVariation > statement names the default variation. For example,

<VariationAlias Condense Condensed >

If the fonts you add have variations not listed in the fontlist file, add a statement for each new variation to this section.Like the <FamilyAlias > statement, the <VariationAlias > statement may be used to declare an alternate name for a font variation. This alternate name may be necessary for fonts from a different system that have a slightly different name.

-- Weight statements

Each <Weight > statement describes a choice in the Weight pop-up menu, and the <DefaultWeight >statement names the default weight. For example,

If the fonts you add have weights not listed in the fontlist file, add a statement for each new weight to this section. When you add <Weight > statements, maintain the light-to-bold weighting order to ensure consistent mapping.

Like the <FamilyAlias > statement, the <WeightAlias > statement may be used to declare an alternate name for a font weight variation. This alternate name may be necessary for fonts from a different system that have a similar but different name.

-- Angle statements

Each <Angle >statement describes a choice in the Angle pop-up menu, and the <DefaultAngle > statement names the default angle. For example,

<Angle Straight >

If the fonts you add have angles not listed in the fontlist file, add a statement for each new angle to this section. Maintain the straight-to-italic order to aid angle mapping.

Like the <FamilyAlias > statement, the <AngleAlias >statement may be used to declare an alternate name for a font angle. This alternate name may be necessary for fonts from a different system that have a similar but different name.

-- Font description statements

statements list the font name and the corresponding family, variation, weight, and angle. To add new fonts to the fontlist file, you add statements describing them. The fontlist file must contain astatement for each font. The  statement contains the corresponding *.afm filename (without the .afm file extension) and the font properties that describe the font. The basic format for a font statement in the fontlist file is the following:

where "OfficialName" is the full name of the font. For example, Garamond may include the following statements:

FrameMaker uses  statements to locate the font files for the font properties you choose when you edit a document, and also to limit the variation, weight, and angle choices to those that are available for the font family you have chosen. If you don't specify a property value in the  statement, FrameMaker uses the default value for that property. With the following example, FrameMaker uses the Tekton-Oblique font when the font family is Tekton, the angle is Oblique, and the weight and variation properties have their default values:

-- Status statements

The <Status > statements usually follow the  statements. In some FrameMaker products, <Status > statements name the fonts to use for text in dialog boxes and rulers. You shouldn't change these statements.

-- PSName statements

Each statement must have a corresponding<PSName >statement that supplies the full font name. <PSName > statements are required for compatibility across platforms and with other font and printing utilities. For example, the standard fontlist file contains the following <PSName > statements for the Times font family:

-- ForeignFamily and MapFont statements

If you open a document that contains fonts not described in the system or user fontlist file, FrameMaker alerts you that the document uses unavailable fonts. If you decide to continue, the most similar available fonts are substituted, either temporarily (if Remember Missing Fonts is selected) or permanently. Adding ForeignFamily and MapFont statments lets you control the handling of unavailable fonts.

The <ForeignFamily > statements name font families that aren't available in this fontlist file but that might be specified in documents that were created using another fontlist file. The statement has the following format:

<ForeignFamily ForeignFontFamilyName >

where "ForeignFontFamilyName" is the name of the font family unavailable on your system.

The <MapFont > statements name which font to substitute for an unavailable font, and they use font properties to describe font faces for both the unavailable and the substitute font. Each <MapFont > statement has the following format:

<MapFont <ForeignFontProperty ><NativeFontProperty >>

where "ForeignFontProperty" is the property of the unavailable font and "NativeFontProperty" is the property of the substitute font.

For example, to map Garamond font styles to Times font styles, add the following statements:

-- ATM statements

The <ATM > statements list the outline fonts and their associated PostScript names. These statements have the following format:

<ATM OfficialName Filename >

where "OfficialName" is the full name of the font.

For example, the fontlist file could have the following <ATM > statements for the Times font family:

-- Alias statement

Normally, you don't need to use an alias statement in the fontlist file, which contains all the font property information. However, FrameMaker might not recognize some font properties. If FrameMaker doesn't recognize a font property when it opens a document, it displays an alert. If this situation occurs, you can use an alias to identify the unrecognized font property. Alias statements have the following format:

<PropertyAlias FontProperty FrameProperty >

where "Property" is the font property for which you are adding the alias statement (Family, Weight, Angle, or Variation),

where "FontProperty" is the name by which that property is known on your system, and

where "FrameProperty" is the name by which FrameMaker recognizes that property.

For example, FrameMaker on UNIX doesn't recognize the Mac OS Demi font weight. But in the weight section of the fontlist file, FrameMaker has a DemiBold weight (DemiBold matches the Mac OS Demi), so the alias statement would be

<WeightAlias Demi DemiBold >

This statement tells FrameMaker to use DemiBold when it encounters a font weight named Demi. In font matching, FrameMaker ignores spaces and isn't case-sensitive. For example, FrameMaker recognizes "ZapfChancery" and "zapfchancery" as "Zapf Chancery."

Making the fonts available tothe equations palette, printer, and Acrobat Distiller

After you add fonts, complete the steps below to make them available to the equations palette, printer, and Acrobat Distiller.

Making special math characters available to the equations palette

Some Type 1 fonts contain special characters for mathmatical equations. To determine if these characters are available for the equations palette, FrameMaker uses the MathCharacters file. The MathCharacters file contains two types of statements:

--Metafamily statements, which name the math font families

-- Character statements, which are within the Metafamily statements and which define each math character within the font family and specify its properties

These statements determine the available choices of a math font. To enable the equations palette to recognize fonts that you install, you must edit the MathCharacters file by adding statements for the font. (First you must add the font definitions to the fontlist file as explained in the previous section, "Guidelines for Font Statements.")

To edit the MathCharacters file:

1. Open one of the following the MathCharacters file in a text editor:

-- If you want the fonts to be accessible to all FrameMaker users, open the MathCharacters file in the FrameMaker installation directory, $FMHOME/fminit/MathCharacters.

-- If you want the fonts to be accessible to yourself only, copy the MathCharacters file into the${HOME}/fminit directory, and open it there.

2. Add statements to the file according to the following guidelines:

Note: The standard MathCharacters file in $FMHOME/fminit contains <MetaFamily >and <Character > statements for the Symbol font. The easiest way to add a math font is to copy these statements and then change the font properties. For example, copy the statements for the Symbol font, and then replace "Symbol" with the name of the new math font family. You may need to make other changes for the new font family, such as removing statements for characters that it doesn't support. For information about the characters included in a font family, see the documentation you received with the font package. Don't remove or change any of the statements for the Symbol font family.

-- MetaFamily statements must have the following format:

<MetaFamily FontFamilyName

<CharacterStatements>

where "FontFamilyName" is the name of the font family as defined in the fontlist file. The <MetaFamily > statement includes a character statement for each math character in the font family. The closing angle bracket must follow the last character statement.

-- Character statements must have the following format:

<CharacterName CharacterCode FontFamily Angle >

where "CharacterName" is the FrameMaker character name, and "CharacterCode" is the hexadecimal code for the character in the FrameMaker character set. You must add a <Character > statement for each math character in the font family you wish to use. To determine the correct FrameMaker character names and hexadecimal codes, see the online manual "FrameMaker Character Sets."

The FontFamily and Angle must be specified in the FrameMaker fontlist file (as discussed in "Guidelines for Font Statements.")

3. Save changes, and close the file.

Downloading fonts to a PostScript printer

Before you can print a document, you must ensure that fonts it uses are available to the printer. To enable FrameMaker to download fonts to the printer on a document-by-document basis, select the Download Fonts option in the Print dialog box. To download the fonts to the printer (that is, to make them printer-resident), use the "lpr" or "lp" command. For example,

(echo "%!" ; echo "serverdict begin 0 exitserver" ;

cat $FMHOME/fontset123/fonts/Tekton.font/Tekton.pfa) | lpr

Printer-resident fonts save time because the fonts needn't be downloaded every time you print. However, the fonts use memory in the printer.

Making fonts available to Acrobat Distiller

If you create Adobe PDF files from FrameMaker, you should edit the Acrobat Distiller Resource file to permit the FrameMaker Distiller module to access the newly installed fonts:

1. Open the $FMHOME/fminit/Distiller/ACRO_RES_DIR file in a text editor.

2. Change this line:

ACRO_RES_DIR=$ACRO_INSTALL_DIR/fontdir:$ACRO_INSTALL_DIR/$ACRO_PRODUCT/Fonts:

ACRO_RES_DIR=$ACRO_INSTALL_DIR/fontdir:$ACRO_INSTALL_DIR/$ACRO_PRODUCT/Fonts:$PSRESOURCEPATH

3. Save changes, and close the file.

Installing and reencoding multiple fonts: a sample script

Below is a sample script that lets you automatically install multiple fonts in the specified source directory. If needed, the script also lets you automatically re-encode binary files to ASCII format. All the font files (*.afm and *.pfa or *.pfb files) must be in the same directory. The script presumes that you have $FMHOME/bin in your PATH environment variable so that Windows or Mac OS outline files can be reencoded from binary to ASCII format.

Disclaimer: Adobe doesn't support this script but provides it as a courtesy.

----------------======== { Start } ========----------------

#!/bin/sh
#
# Author: Simon BUCH @ Adobe Systems Inc.
# Copyright: Adobe Systems Incorporated 2001, all rights reserved
#
# Notes: This script is supplied as is, without warranties
# nor support. It is the responsibility of the user
# to determine the suitability of this script.
#
#

usage () {
echo Usage:
echo "\t`basename ${0}` [-v] SourceDiry"
echo
echo "This script attempts to take the PostScript Type 1 fonts"
echo "from ''SourceDiry'' and creates a directory hierarchy"
echo "containing the fonts and appropriate PostScript resource"
echo "files. For example, installing font set#152 will install"
echo "the fonts in the directories structure below the current"
echo "directory:"
echo "\tfonts/GillSans.font/GillSans.afm"
echo "\tfonts/GillSans.font/GillSans.pfa"
echo "\tfonts/GillSans-Light.font/GillSans-Light.afm"
echo "\tfonts/GillSans-Light.font/GillSans-Light.pfa"
echo "\tfonts/GillSans-LightItalic.font/GillSans-LightItalic.afm"
echo "\tfonts/GillSans-LightItalic.font/GillSans-LightItalic.pfa"
echo "\tfonts/GillSans-Italic.font/GillSans-Italic.afm"
echo "\tfonts/GillSans-Italic.font/GillSans-Italic.pfa"
echo "\tfonts/GillSans-Bold.font/GillSans-Bold.afm"
echo "\tfonts/GillSans-Bold.font/GillSans-Bold.pfa"
echo "\tfonts/GillSans-BoldItalic.font/GillSans-BoldItalic.afm"

echo "\tfonts/GillSans-BoldItalic.font/GillSans-BoldItalic.pfa"
echo ""
echo "It is the responsibility of the user to ensure they have the"
echo "correct environment variables set for their applications"
}

#
# Check some command line parameters
#
[ ${#} -eq 0 ]&& { usage ; exit 1 ; }
[ X${1} = X"-v" ]&& { Verbose=On ; shift ; }
[ ${#} -ne 1 ]&& { usage ; exit 1 ; }

SourceDiry=${1}
[ ! -d "${SourceDiry}" ]&& { echo "Could not open directory: ${SourceDiry}" ; exit 1 ; }

#
# Find the ASCII font metric files, located in the source directory
#
MacAFMfiles=`/bin/ls ${SourceDiry} | egrep -i \.afm$ | sed "s=^=${SourceDiry}/="`

#
# Set a trap to clean up after ourselves
#
CWD=`pwd`
Process=/tmp/${$} ; mkdir ${Process}
trap "rm -fr ${Process}" 0

#
# Convert Macintosh \r carriage returns (CR) to Unix style \n Line Feeds (LF)
#
for EachAFM in ${MacAFMfiles} ; do
EachFile=`basename ${EachAFM} .[Aa][Ff][Mm]`
[ ${Verbose} ]&& echo "Gathering font metrics ${EachFile}"
tr '\r' '\n' < ${EachAFM} > ${Process}/${EachFile}.afm
done

#
# Find the full PostScript fontname stored in the afm files
#
Variants=`egrep FontName ${Process}/*.afm | sed 's/FontName //'`

#
# For each AFM PostScript font file ...
#
for diry in ${Variants} ; do
#
# Find the pathname of the font with which we're dealing
#
AFMfile=`expr ${diry} : '^$.*$:.*'`

#
# Create font directories
#
Variant=`expr ${diry} : '^.*:$.*$'`
pathfile=`expr ${AFMfile} : "${Process}/$.*$\.[Aa][Ff][Mm]"`
[ ${Verbose} ] || echo Creating font: ${Variant}
mkdir -p fonts/${Variant}.font

#
# Copy the ASCII font metric (AFM) file to the directory
# ... renaming it to reflect the full PostScript fontname
#
[ ${Verbose} ]&& echo && echo "... creating ${Variant}.afm"
cp ${AFMfile} fonts/${Variant}.font/${Variant}.afm

#
# Do we have a PFA file?
#
if [ -s ${SourceDiry}/${pathfile}.[Pp][Ff][Aa]] ; then
#
# Move the ASCII font outline (PFA) file to the directory
# ... renaming it to reflect the full PostScript fontname
#
[ ${Verbose} ]&& echo "... copying ${Variant}.pfa"
cp ${SourceDiry}/${pathfile}.[Pp][Ff][Aa] fonts/${Variant}.font/${Variant}.pfa
#
# Do we have a PFB file?
#
elif [ -s ${SourceDiry}/${pathfile}.[Pp][Ff][Bb]] ; then
#
# Convert the Binary font outline to ASCII format
#
[ ${Verbose} ]&& echo "... converting ${pathfile} font outline to ${Variant}.pfa"
fmAdobePCFont ${SourceDiry}/${pathfile}.[Pp][Ff][Bb] fonts/${Variant}.font/${Variant}.pfa
#
# Or is it a Macintosh PostScript font file?
#
elif [ -s ${SourceDiry}/${pathfile} ] ; then
#
# Convert the Macintosh outline to ASCII format
#
[ ${Verbose} ]&& echo "... converting Macintosh font "${pathfile}" to ${Variant}.pfa"
fmAdobeMacFont ${SourceDiry}/${pathfile} fonts/${Variant}.font/${Variant}.pfa
else
#
# No ASCII or Binary format outline font file?

#
echo "Error: no font outline file (PFA nor PFB) found for ${Variant}"
echo "Please contact your font vendor"
fi
done
[ ${Verbose} ]&& echo

#
# Create a PostScript resources file
#
[ ${Verbose} ]&& echo "Generating a PostScript Resource File"
makepsres -d -o PSres.upr fonts

#
# Output a warning to inform the user to update their PSRESOURCEPATH
#
echo
echo Note: Remember to update your PSRESOURCEPATH environment variable to
echo access this new PostScript resource directory, before launching FrameMaker.
echo For example:
echo "\tPSRESOURCEPATH=`pwd`:\$PSRESOURCEPATH:: ; export PSRESOURCEPATH"

----------------======== { End } ========----------------