   Copyright (C) 1990, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  
  This file is part of GNU Ghostscript.
  
  GNU Ghostscript is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility to
  anyone for the consequences of using it or for whether it serves any
  particular purpose or works at all, unless he says so in writing.  Refer to
  the GNU General Public License for full details.
  
  Everyone is granted permission to copy, modify and redistribute GNU
  Ghostscript, but only under the conditions described in the GNU General
  Public License.  A copy of this license is supposed to have been given to
  you along with GNU Ghostscript so you can know your rights and
  responsibilities.  It should be in a file named COPYING.  Among other
  things, the copyright notice and this notice must be preserved on all
  copies.
  
  Aladdin Enterprises is not affiliated with the Free Software Foundation or
  the GNU Project.  GNU Ghostscript, as distributed by Aladdin Enterprises,
  does not depend on any other GNU software.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

This file, fonts.txt, describes the fonts and font facilities supplied
with Ghostscript.

For an overview of Ghostscript and a list of the documentation files, see
README.

About Ghostscript fonts
=======================

Most of the font files supplied with Ghostscript have a .pfb extension; a
few have a .pfa or .gsf extension.  Each file defines one (transformable)
font specified in outline form.  They are ordinary Type 1 PostScript outline
fonts, and can be given to any PostScript language interpreter.  Files with
.pfa or .pfb extension are also compatible with Adobe Type Manager and with
tools that don't include a full PostScript language interpreter; files with
.gsf extension are not compatible with ATM or other tools.  Starting with
release 4.0, Ghostscript configurations compiled with the `ttfont' option
can also use TrueType fonts (.ttf).

The only other font-related file that Ghostscript needs for proper operation
is a file called Fontmap.  This file maps font names (such as /Times-Roman)
to font file names (such as n021003l.pfb) or aliases (such as
NimbusNo9L-Regu).

The free fonts supplied with Ghostscript fall into three groups:

	- 35 basic PostScript fonts (Times, Helvetica, Courier, Symbol,
	etc.)  These are commercial-quality Type 1 fonts.  See the file
	`Fontmap' for the complete list.

	- Fonts derived from the public domain Hershey fonts, with
	improvements (such as adding accented characters) by Thomas Wolff.
	These are quite different from traditional printer or display fonts;
	the file `hershey.txt' describes them in more detail.

	- A few miscellaneous fonts including Cyrillic and kana fonts.

The 35 basic fonts are normally distributed in a file called
`ghostscript-fonts-std-N.NN.tar.gz', the rest in a file called
`ghostscript-fonts-other-N.NN.fonts.tar.gz'.

The file gs_fonts.ps, which is loaded as part of Ghostscript initialization,
arranges to load fonts on demand using the information from Fontmap.  If you
want to preload all of the known fonts, invoke the procedure
	loadallfonts
This is not done by default, since the fonts occupy about 50K each and there
are a lot of them.

If you want to try out the fonts, prfont.ps contains code for printing a
sampler.  Load this program, by including it in the gs command line or by
invoking
	(prfont.ps) run
and then to produce a sampler of a particular font, invoke
	/fontName DoFont
e.g.
	/Times-Roman DoFont

About the Kanji fonts
---------------------

Mr. Tetsurou Tanaka of the Department of Engineering, University of Tokyo,
has created a set of free Kanji fonts that is freely available on the
Internet for anonymous FTP from moe.ipl.t.u-tokyo.ac.jp:/Font and is
distributed with Ghostscript.  Anyone can use these fonts as they are or
with some format translation, and redistribute them without reporting.  If
you redistribute them, you must inform the recipient that he can get the
original from the abovementioned FTP site, so that he could get the newest
version later.

The fonts include a README file in Japanese.  Here is some English
documentation supplied by Mr. Kiyotaka Sakai, also of the University of
Tokyo.

    The following four fonts are different styles of the same characters
    (JISX208). These fonts also needs wadalab-sym.tar.Z in common.

    wadalab-mincho-0-8.tar.gz
    wadalab-mincho-0-12.6.tar.gz
    wadalab-gothic-0-13.5.tar.gz
    wadalab-maru-0-8.4.tar.gz

    And the following two fonts are the other different styles of the same
    characters(JISX0212).

    wadalab-mincho-1-8.tar.gz
    wadalab-maru-1-8.tar.gz

    These fonts are postscript(type1) fonts. You can convert them to
    Metafont, Type1(PFA) font, TeX font(for japanese TeX), BDF font,
    Shotaikurabu font by using wftomf.c, wftopfa.c, wftodm.c, bdfmerge.c
    wftovf.c in tools directory.

In order to conform to MS-DOS naming restrictions, we have renamed the
original font files as follows:
	Name		Original name
	----		-------------
	got013-5.taz	wadalab-gothic-0-13.5.tar.gz
	mar08-4.taz	wadalab-maru-0-8.4.tar.gz
	mar18.taz	wadalab-maru-1-8.tar.gz
	min012-6.taz	wadalab-mincho-0-12.6.tar.gz
	min08-4.taz	wadalab-mincho-0-8.4.tar.gz
	min18.taz	wadalab-mincho-1-8.tar.gz
	sym-4.taz	wadalab-sym.4.tar.gz

Platform fonts
==============

Starting with release 2.6.1, Ghostscript uses whatever font technology is
provided by the system on which it runs, by using the system's API for
displaying text.  On MS Windows this may be TrueType, or it may be ATM;
Ghostscript neither knows nor cares.

The PostScript language specifies that fonts are data structures with
particular contents (e.g., they include a bounding box for the font, an
Encoding vector for specifying the character set, etc.), and it is fairly
common for PostScript files to make use of this fact; also, characters can
be used as clipping regions, and can be arbitrarily rotated, skewed,
expanded/condensed, etc. algorithmically.  Most of this information is
available in one form or another from the underlying graphics system, but
one crucial piece is not: the actual scalable outlines of the characters,
which Ghostscript needs in order to implement clipping with character
shapes and to implement arbitrarily transformed characters.  Consequently,

	Ghostscript needs the scalable outlines of any font mentioned
	in a document, and will load them from the disk (.PFA, .PFB, or
	.GSF file) in the usual way, even if it uses the platform's font
	machinery for displaying the characters.

To make matters worse, platforms use different names for their standard
fonts.  For example, the Times Roman font, for which PostScript files use
the name "Times-Roman", may be known as "Times-Roman", "Times Roman", "Tms
Rmn", "Times New Roman", or "TimesNewRoman".  The name may even be
completely different: the usual Helvetica-equivalent TrueType font is
called "Arial".  Now, it is possible to cope with this situation by
introducing aliases in Fontmap, but there are two reasons why the
current Ghostscript release does not do this:

	1) Naming in different systems is so unstandardized that there
does not seem to be a small set of alternative names that is likely to
cover most of the situations.  All 5 of the above names for Times Roman
have been seen in Windows and OS/2 environments, depending on system
version, TrueType vs.  ATM, and other unknown factors.

	2) Each alias takes up a substantial amount of space (several
hundred bytes) at run time.  If each of the standard 35 fonts has 3
additional aliases, this might amount to 50K of wasted space.  This is a
lot on a PC, although running under Windows in enhanced mode, it might not
be a problem.

If you don't seem to be getting nice characters on the screen under MS
Windows, you can try adding aliases to the Fontmap, according to the
documentation found there.

Adding your own fonts
=====================

Ghostscript can use any Type 0, Type 1, Type 3, Type 4, or Type 42 font that
is acceptable to other PostScript language interpreters or to ATM, including
MultiMaster fonts.  Starting with release 4.0, Ghostscript can also use
TrueType fonts (if Ghostscript was compiled with the `ttfont' option).
Ghostscript also provides a way to construct a (low-quality) Type 1 font
from a bitmap font in BDF format, which is a popular format in the Unix
world.

If you want to add fonts of your own, you must edit Fontmap to include an
entry for your new font at the end.  The format for entries is documented
in the Fontmap file.  Since later entries in Fontmap override earlier
entries, any fonts you add will supersede the corresponding fonts supplied
with Ghostscript.

In the PC world, Type 1 fonts are customarily given names ending in .PFA or
.PFB.  Ghostscript can use these directly; you just need to make the entry
in Fontmap.  If you are going to use a commercial Type 1 font (such as fonts
obtained in conjunction with Adobe Type Manager) with Ghostscript, please
read carefully the license that accompanies the font; Aladdin Enterprises
takes no responsibility for any possible violations of such licenses.  The
same applies to TrueType fonts, whose names customarily end in .TTF.

Converting BDF fonts
--------------------

If you want to convert a BDF file to a scalable outline, use the program
bdftops.ps (and invoking shell script bdftops.bat or bdftops).  Run the
shell command
	bdftops <BDF_file_name> [<AFM_file1_name> ...] <your_gsf_file_name>
	  <font_name> <uniqueID> [<XUID>] [<encoding_name>]
e.g.,
	bdftops pzdr.bdf ZapfDingbats.afm pzdr.gsf
	  ZapfDingbats 4100000 1000000.1.41
(Obviously, you would enter this all on one line; the example is split so
it will fit on the page.)  Then make an entry for the .gsf file in Fontmap
as described above.  See the end of this document for more detail.

For developers only
===================

The rest of this document is very unlikely to be of value to ordinary
users.

Contents of fonts
-----------------

As noted above, Ghostscript accepts fonts in the same formats as PostScript
interpreters.  Type 0, 1, and 3 fonts are documented in the PostScript
Language Reference Manual (Second Edition); detailed documentation for Type
1 fonts appears in a separate Adobe book.  Type 42 (encapsulated TrueType)
fonts are documented in an Adobe supplement; the TrueType format is
documented in publications available from Apple and Microsoft.  Type 4 fonts
are not documented anywhere; they are essentially Type 1 fonts with a
BuildChar or BuildGlyph procedure.

Precompiling fonts
------------------

You can compile any Type 1 font into C and link it into the Ghostscript
executable.  (Type 1 fonts include any font whose name ends with .pfa or
.pfb, and it also includes all the Ghostscript .gsf fonts except for the
Hershey fonts.)  This doesn't have any effect on rendering speed, but it
eliminates the time for loading the font dynamically, which may make a big
difference in total rendering time, especially for multi-page documents.
Fonts that have been precompiled and linked in this way do not need to
appear in the Fontmap, although if they do appear there, no harm is done.

The utility for precompiling fonts is called font2c.  Note that font2c is
a PostScript language program, so you must have Ghostscript already
running to be able to run font2c; you must also have entries in the
Fontmap for the fonts you want to compile.  For example, to precompile
the Times-Italic font,
	font2c Times-Italic ptmri.c
where the first argument is the font name and the second is the name of
the .c file.  You can use any file name you want, as long as it ends in
.c.  It doesn't have to be limited to 8 characters, unless your operating
system requires this.  We suggest that you use names xxxx.c, where
xxxx.gsf or xxxx.pfa is the name of the font file in the Fontmap file,
just so you don't have to keep track of another set of names.  (If you are
running on a VMS platform, or another platform where the C compiler has a
limit on the length of identifiers, you must do something slightly more
complicated; see the section 'Platforms with identifier length limits'
below.  Also, on VMS, you must put quotes "" around the font name so that
the VMS command processor doesn't convert the name to lower case.)

For VMS environments, see the directions in the file make.txt, and ignore
the rest of this section.

Note that ncrr.c, ptmr.c, etc. are not supplied with the Ghostscript
fileset, since they are quite large and can easily be recreated using the
font2c program as described above.  There is a makefile called cfonts.mak
that will run font2c on all the fonts supplied with Ghostscript.  Invoke it
with
	make -f cfonts.mak
On some systems, you may have to omit the space following the -f, i.e.,
	make -fcfonts.mak

Besides running font2c, you must arrange things so that the fonts will be
compiled, and linked into the executable.  To do this, add the compiled
fonts "feature" to your platform-specific makefile.  On MS-DOS systems, you
edit tc.mak, bc.mak, bcwin.mak, msc.mak, or watc.mak; on Unix systems, you
edit ansihead.mak, cc-head.mak, or gcc-head.mak, and then execute tar_cat.
Find the definition of the FEATURE_DEVS macro in the makefile, e.g.,
	FEATURE_DEVS=level2.dev pdf.dev
and add ccfonts.dev, e.g.,
	FEATURE_DEVS=level2.dev pdf.dev ccfonts.dev

Next, you must add the specific fonts to the generic makefile.  On MS-DOS
systems, you edit gs.mak; on Unix systems, you edit makefile.  The makefile
already has rules for the standard 35 fonts supplied with Ghostscript.
Find the line in the relevant makefile that says
	#ccfonts1_=<something>
Remove the # mark from this line, and from all the following lines down to
and including the one that says
	#ccfonts9=<something>
This is all you need to do for the standard fonts.  The next couple of
paragraphs describe how to compile in other fonts, such as the Utopia or
Kana fonts or your own fonts.

Suppose you want to compile the Kana fonts into the executable.  First,
pick one of ccfonts10 through 15 as the place you will do this, say
ccfonts10.  Add your compiled font file names, e.g.,
	ccfonts10_=fhirw.$(OBJ)
If the line gets too long, use another line of the same form, e.g.,
	ccfonts11_=fkarw.$(OBJ)
Just below this, you will find a line that says
	ccfonts10_=
Add your own fonts to the end of this line, e.g.,
	ccfonts10=Calligraphic_Hiragana
Notice that you must replace `-' by `_' in the font name.  Again, if
the line gets too long, add another line of the same form, e.g.,
	ccfonts10=Calligraphic_Hiragana
	ccfonts11=Calligraphic_Katakana

After all the lines of this form, add a pair of lines to compile each font,
separating these entries from the ccfonts* lines and from each other by a
blank line.  In our example:

	fhirw.$(OBJ): fhirw.c $(CCFONT)
		$(CCCF) fhirw.c

	fkarw.$(OBJ): fkarw.c $(CCFONT)
		$(CCCF) fkarw.c

Finally, run `make'.  The executable will now include the fonts you added.
They will be present in FontDirectory when Ghostscript starts up.

Precompiling fonts on platforms with identifier length limits
-------------------------------------------------------------

On some platforms, the C compiler and/or linker have a limit on the number
of significant characters in an identifier.  On such platforms, you must
do a little extra work.

Let N be the maximum number of significant characters in an identifier
(typically 31).  For each font whose name is longer than N-5 characters,
pick an arbitrary identifier that we will call the "short name".  This can
be any string you want, as long as it contains only letters, digits, and
underscores; is no longer than N-5 characters; and is not the same as any
other font name or short name.  A good choice for this would be to use the
name of the C file.  (There is no harm in doing this for fonts with names
shorter than N-5 characters, it's just not necessary.)

You must do two different things for fonts that require a short name.
First, you must supply the short name as a third argument to the font2c
program.  For example, to compile NewCenturySchlbk-BoldItalic using the
short name "pncbi",
	font2c NewCenturySchlbk-BoldItalic pncbi.c pncbi
Then when you add the font to the gsaddmod line in the makefile, use the
short name, not the actual font name, e.g.,
	ccfonts2=pncbi
instead of
	ccfonts2=NewCenturySchlbk_BoldItalic
Everything else is as described above.

This procedure doesn't change the name of the font in the Fontmap, or as
seen from within Ghostscript; it's just a workaround for a limitation of
some older compilers.

Font names and unique IDs
-------------------------

If you create your own fonts, and are only going to use them within your own
organization, you should use UniqueID values between 4000000 and 4999999 as
described just below; if you are going to distribute fonts, call Adobe and
get them to assign you some UniqueIDs and also an XUID for your
organization.  The current (September 1993) UniqueID Coordinator is Terry
O'Donnell; he is very helpful and will probably be able to assign you the
numbers over the phone.

The suggested temporary UniqueID for a font looks like:
	4TTWVE0
where
	TT is a two-digit number representing the typeface,
	W represents the weight (normal, bold, ...),
	V represents the variant (normal, italic, oblique, ...), and
	E represents the expansion (normal, condensed, ...).
This scheme will not work forever.  As soon there are more 99 typefaces, or
more than 9 weights or variants, we will have to do something else. But it
suffices for the near future.

XUIDs are a Level 2 PostScript feature that serves the same function as
UniqueIDs, but is not limited to a single 24-bit integer.  The bdftops
program creates XUIDs of the form [-X- 0 -U-] where -X- is the organization
XUID and -U- is the UniqueID.  (Aladdin Enterprises' organization XUID is
107; do not use this for your own fonts that you distribute.)

Ghostscript fonts are stored on files, and the file names must comply
with the 8-character limit imposed by MS-DOS and other operating systems.
We therefore construct the filename for a font in a way somewhat similar to
the construction for temporary UniqueIDs:
	FTTWVVVE.gsf
where F is the foundry, TT a two-letter abbreviation for the typeface, and
W, V, and E the weight, variant, and expansion.  Since a font can have
multiple variants, we allocate three letters to that (for example, Lucida
Regular Sans Typewriter Italic).  If a font has four variants, you're on
your own.  If a font does have multiple variants, it's best to add the
expansion letter `r', so that it is clear which letters are variants and
which the expansion.

This scheme is very close to the one proposed in `Filenames for fonts',
published in the first 1990 issue of TUGboat (the journal of the TeX Users
Group).

In the following tables, we made no attempt to be exhaustive.  Instead, we
have simply allocated entries for those things that we needed for the fonts
that we are actually distributing.

foundries:
----------
b = Bitstream
f = freely distributable/public domain fonts
n = IBM
p = Adobe (`p' for PostScript)
u = URW[++]

typefaces:
id   name			  filename prefix
----------------------------------------------------------------
08 = Avant Garde		= pag		(Adobe)
11 = Bookman			= pbk		(Adobe)
01 = CharterBT			= bch		(Bitstream)
02 = Courier			= ncr		(IBM)
03 = Helvetica			= phv		(Adobe)
04 = New Century Schoolbook	= pnc		(Adobe)
09 = Palatino			= ppl		(Adobe)
05 = Symbol			= psy		(Adobe)
06 = Times			= ptm		(Adobe)
--   Utopia			= put		(Adobe)
07 = Zapf Chancery		= zc		(public domain)
10 = Zapf Dingbats		= pzd		(Adobe)
12 = public domain Cyrillic	= fcy		(public domain)
13 = Kevin Hartig Hiragana	= fhi		(shareware)
14 = Kevin Hartig Katakana	= fka		(shareware)

90 = Hershey Gothic English	= hrge
91 = Hershey Gothic Italian	= hrit
92 = Hershey Gothic German	= hrgr
93 = Hershey Greek		= hrgk
94 = Hershey Plain		= hrpl
95 = Hershey Script		= hrsc
96 = Hershey Symbol		= hrsy

weights:
--------
0 = normal			= r
1 = bold			= b
2 = book			= k
3 = demi			= d
4 = light			= l

variants:
---------
0 = normal			= r (omitted when the weight is normal)
1 = italic			= i
2 = oblique			= o
3 = script/handwritten/swash	= w

expansions:
-----------
0 = normal			= r (omitted when the weight and variant
                                   are normal)
1 = narrow			= n

Converting BDF fonts to .gsf (Type 1) fonts
-------------------------------------------

The bdftops conversion program takes the following arguments:

	bdftops xx.bdf [yy1.afm ...] zz.gsf fontname UniqueID [XUID]
	  [encodingname]

These arguments have the following meanings:

	xx.bdf - the input bitmap file, a BDF file
	yy*.afm - the AFM files giving the metrics (optional)
	zz.gsf - the output file
	fontname - the font name
	UniqueID - the UniqueID, as described above
	XUID - the XUID, in the form n1.n2.n3... (optional)
	encodingname - the encoding for the font (optional)

Currently, the defined encodings are StandardEncoding, ISOLatin1Encoding,
SymbolEncoding, and DingbatsEncoding. If the encoding is omitted,
StandardEncoding is assumed.
