Move xfs/libFS docs to app/xfs & lib/libFS

Signed-off-by: Alan Coopersmith <alan.coopersmith@sun.com>

7 files changed, 1 insertions, 1748 deletions

diff --git a/Makefile.am b/Makefile.am
index 65e252e..8c92149 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -157,8 +157,6 @@ EXTRA_DIST = \
 	specs/Xext/xtest1.mm \
 	specs/Xext/xtestlib.ms \
 	specs/Xext/xtest.ms \
-	specs/xfs/design.ms \
-	specs/xfs/FSlib.doc \
 	specs/Xi/encoding.ms \
 	specs/Xi/library.ms \
 	specs/XIM/xim.ms \
diff --git a/configure.ac b/configure.ac
index 308098e..fdcab5f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -78,7 +78,6 @@ AC_OUTPUT([Makefile
            hardcopy/Xaw/Makefile
            hardcopy/XDMCP/Makefile
            hardcopy/Xext/Makefile
-           hardcopy/xfs/Makefile
            hardcopy/Xi/Makefile
            hardcopy/XIM/Makefile
            hardcopy/XKB/Makefile
diff --git a/hardcopy/Makefile.am b/hardcopy/Makefile.am
index 0ea83b9..ab756c3 100644
--- a/hardcopy/Makefile.am
+++ b/hardcopy/Makefile.am
@@ -21,5 +21,5 @@
 #  Process this file with autoconf to create configure.
 
 SUBDIRS = BDF CTEXT FSProtocol i18n ICCCM ICE man rstart RX saver SM X11 \
-          Xaw XDMCP Xext xfs Xi XIM XKB XLFD Xmu XPRINT XProtocol Xserver \
+          Xaw XDMCP Xext Xi XIM XKB XLFD Xmu XPRINT XProtocol Xserver \
           Xt xtrans Xv
diff --git a/hardcopy/xfs/Makefile.am b/hardcopy/xfs/Makefile.am
deleted file mode 100644
index 74b4342..0000000
--- a/hardcopy/xfs/Makefile.am
+++ /dev/null
@@ -1,24 +0,0 @@
-#  Copyright 2005 Red Hat, Inc.
-# 
-#  Permission to use, copy, modify, distribute, and sell this software
-#  and its documentation for any purpose is hereby granted without fee,
-#  provided that the above copyright notice appear in all copies and
-#  that both that copyright notice and this permission notice appear in
-#  supporting documentation, and that the name of Red Hat not be used in
-#  advertising or publicity pertaining to distribution of the software
-#  without specific, written prior permission.  Red Hat makes no
-#  representations about the suitability of this software for any
-#  purpose.  It is provided "as is" without express or implied warranty.
-# 
-#  RED HAT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
-#  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
-#  NO EVENT SHALL RED HAT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
-#  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-#  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
-#  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
-#  USE OR PERFORMANCE OF THIS SOFTWARE.
-#
-#  Process this file with autoconf to create configure.
-
-hardcopydir = @HARDCOPYDIR@/xfs
-dist_hardcopy_DATA = design.PS.gz
diff --git a/hardcopy/xfs/design.PS.gz b/hardcopy/xfs/design.PS.gz
deleted file mode 100644
index 2ed0702..0000000
--- a/hardcopy/xfs/design.PS.gz
+++ /dev/null
diff --git a/specs/xfs/FSlib.doc b/specs/xfs/FSlib.doc
deleted file mode 100644
index 8cf5de0..0000000
--- a/specs/xfs/FSlib.doc
+++ /dev/null
@@ -1,222 +0,0 @@
-$Xorg: FSlib.doc,v 1.3 2000/08/17 19:42:50 cpqbld Exp $
-
-Protocol requests
-
-These functions make protocol requests corresponding to their names.
-
-Connection Setup
-
-FSServer     *
-FSOpenServer(server)
-    char       *server;
-
-Creates a connection to the font server specified in the 'server' string.
-
-FSCloseServer(svr)
-    FSServer     *svr;
-
-Closes the connection to the font server.
-
-Font Manipulation
-
-Font
-FSOpenXBitmap(svr, hint, fmask, name, originalid)
-    FSServer     *svr;
-    fsBitmapFormat hint;
-    fsBitmapFormatMask	fmask;
-    char       *name;
-    Font	*originalid;
-
-Opens the font that matches the given name (which may have '*' and '?'
-as wildcards).  The hint contains format information that will probably
-be used in subsequent QueryXBitmaps() requests.  The fmask tells which
-bits in the mask are valid.  If originalid is non-zero, then the server
-already has the font opened under that ID.
-
-FSCloseFont(svr, fid)
-    FSServer     *svr;
-    Font        fid;
-
-Closes the font.
-
-char      **
-FSListFonts(svr, pattern, maxNames, actualCount)
-    FSServer     *svr;
-    char       *pattern;
-    int         maxNames;
-    int        *actualCount;
-
-Returns the full names of the fonts matching pattern.  Up to maxNames
-names will be returned.  The actual value number be placed in
-actualCount.  The return value should be freed with FSFreeFontNames.
-
-FSFreeFontNames(list)
-    char    **list
-
-Frees the list of font names returned by FSListFonts.
-
-char      **
-FSListWithXInfo(svr, pattern, maxNames, actualCount, info, pprops, offsets,
-					prop_data)
-    FSServer     *svr;
-    char       *pattern;
-    int         maxNames;
-    int        *actualCount;
-    fsFontHeader ***info;
-    fsPropInfo ***pprops;
-    fsPropOffset ***offsets;
-    unsigned char ***prop_data;
-
-Returns the full names of the fonts matching pattern.  Up to maxNames
-names will be returned.  The actual value number be placed in
-actualCount, and each font's header and property information will also
-be returned.
-
-int
-FSQueryXInfo(svr, fid, info, props, offsets, prop_data)
-    FSServer     *svr;
-    Font        fid;
-    fsFontHeader *info;
-    fsPropInfo	 *props;
-    fsPropOffset **offsets;
-    unsigned char **prop_data;
-
-Returns the font's header information.
-
-int
-FSQueryXExtents8(svr, fid, range_type, str, str_len, extents)
-    FSServer   *svr;
-    Font        fid;
-    Bool	range_type;
-    unsigned char *str;
-    unsigned long str_len;
-    fsCharInfo **extents;
-
-int
-FSQueryXExtents16(svr, fid, range_type, str, str_len, extents)
-    FSServer   *svr;
-    Font        fid;
-    Bool	range_type;
-    fsChar2b	*str;
-    unsigned long str_len;
-    fsCharInfo **extents;
-
-Returns the extents of the given characters.  If 'range_type' is set,
-the 'str' is considered a range, otherwise its considered a list of
-characters.  A NULL str when range_type is set means that all the
-character extents will be returned.
-
-int
-FSQueryXBitmaps8(svr, fid, format, range_type, str, str_len,, offsets, glyph_data)
-    FSServer     *svr;
-    Font        fid;
-    fsRange	*range;
-    fsBitmapFormat format;
-    Bool	range_type;
-    unsigned char *str;
-    unsined long str_len;
-    unsigned long **offsets;
-    unsigned char **glyph_data;
-
-int
-FSQueryXBitmaps16(svr, fid, format, range_type, str, str_len,, offsets, glyph_data)
-    FSServer     *svr;
-    Font        fid;
-    fsRange	*range;
-    fsBitmapFormat format;
-    Bool	range_type;
-    fsChar2b	*str;
-    unsined long str_len;
-    unsigned long **offsets;
-    unsigned char **glyph_data;
-
-Returns the font's bitmaps in the requested format.  The other arguments
-are used as in QueryExtents above.
-
-Extensions
-
-char      **
-FSListExtensions(svr, next)
-    FSServer     *svr;
-    int        *next;
-
-Lists any extension built into the font server.
-
-Bool
-FSQueryExtension(svr, name, major_opcode, first_event, first_error)
-    FSServer     *svr;
-    char       *name;
-    int        *major_opcode;
-    int        *first_event;
-    int        *first_error;
-
-Returns information on the specified extension.
-
-FSFreeExtensionList(list)
-    char      **list;
-
-Frees the list returned by FSListExtensions().
-
-
-Helper functions -- these don't map to protocol requests, but
-can make writing a FS client simpler.
-
-Synchronization
-
-FSSync(svr, discard)
-    FSServer     *svr;
-    Bool        discard;
-
-Flushes the output queue and waits for a reply from the server,
-which will flush the server's output queue.
-
-int
-(* FSSynchronize(svr, onoff)) ()
-    FSServer     *svr;
-    int         onoff;
-
-Controls whether the server does every request in synchronous form.
-
-int
-(* FSSetAfterFunction(svr, func)) ()
-    FSServer     *svr;
-    int         (*func) ();
-
-Sets the function that will be called after every request.  This
-is usually NULL or FSSync().
-
-FSFlush(svr)
-    FSServer     *svr;
-
-Flushes any queued requests to the font server.
-
-Error Handling
-
-int         (* FSSetErrorHandler(handler)) ()
-    int         (*handler) ();
-
-Changes the error handler to 'handler'.  A NULL value will reset
-it to use the default.
-
-int         (* FSSetIOErrorHandler(handler)) ()
-    int         (*handler) ();
-
-Changes the I/O error handler to 'handler'.  A NULL value will reset
-it to use the default.
-
-Miscellaneous
-
-long
-FSMaxRequestSize(svr)
-    FSServer     *svr;
-
-Returns the largest request size in 4 byte quantities) that the
-server can handle.
-
-char       *
-FSServerName(server)
-    char       *server;
-
-Returns the name that FSlib would use to connect to the server.
-Translates a NULL in the value of $FONT_SERVER.
-
diff --git a/specs/xfs/design.ms b/specs/xfs/design.ms
deleted file mode 100644
index feb3c96..0000000
--- a/specs/xfs/design.ms
+++ /dev/null
@@ -1,1498 +0,0 @@
-.\" $Xorg: design.ms,v 1.3 2000/08/17 19:42:51 cpqbld Exp $
-.\" roff -ms
-.de Ip
-.IP \(bu 3
-..
-.de Qp
-.nr PS -2
-.nr VS -2
-.QP
-..
-.\"	These macros should select a typewriter font if you have one.
-.de LS
-.KS
-.LD
-.ft CB
-.ta .6i 1.2i 1.8i 2.4i 3i 3.6i 4.2i
-..
-.de LE
-.ft P
-.DE
-.KE
-..
-.de Ls
-.nr PS -2
-.nr VS -3
-.sp
-.LS
-..
-.de Le
-.LE
-.nr PS +2
-.nr VS +3
-.LP
-..
-.TL
-Font server implementation overview
-.AU
-Dave Lemke
-.AI
-Network Computing Devices, Inc.
-Copyright \(co 1991 Network Computing Devices, Inc.
-.NH
-Introduction
-.PP
-The font server uses the same client/server model as X.  The basic structure
-is that of the X Consortium X11R5 X server, and those
-who know that code should find the 
-.I os
-and 
-.I difs
-(device independent font server) layers familiar.
-.nf
-.Ls
-
-                        +-----------------+
-                  +-----|      difs       |------+
-                  |     +-----------------+      |
-                  |                              |
-                +----+                  +------------+
-                | os |                  | renderers  |
-                +----+                  +------------+
-.Le
-.fi
-\fBDefinitions\fR
-.Ip
-Renderer.  Code that knows how to take font data in its raw format and
-convert it to the font server's format.
-.Ip
-Font Path Element (FPE).  An instance of a renderer, associated with a
-specific font source, (ie a directory of PCF bitmaps).
-.PP
-The 
-.I difs
-layer interprets the requests, and handles the renderer
-independent work.  This includes error checking of requests, and the
-top level font database.  It also contains various utility functionality
-such as caching and byte swapping.
-.PP
-The 
-.I os
-layer sets up the communications channel, reads requests and
-sends the raw data of replies and events.  It also handles font server
-configuration issues, controlled by command line arguments and
-a configuration file.
-.PP
-The renderer layer contains all font-specific code, 
-and is responsible for rendering a font (which may mean
-just reading a bitmap from disk, or may include scaling of outline
-data), computing a fonts properties and header information.
-.NH
-Startup
-.PP
-At startup, the font server handles any command line arguments,
-initializes any OS-specific data, and then sets up the communications.
-Various internal databases are then initialized (extensions, the font
-catalogue, etc).
-.PP
-The config file, an ordered list of font sources, cache size hints,
-default resolutions, and security information, is then read in.  Each
-of these source names could be a directory name, the name of another
-font server, or some other string that a particular renderer can
-recognize.
-.PP
-The default font catalogue is then built up by taking each of the font
-source names and comparing it with the names a renderer recognizes.
-The one that matches this name will become attached to this
-source.  A renderer will ``understand'' a name if it can parse the data
-in that directory, or recognize that it is a valid font server address,
-or recognizes a special string.  Thus a collection of valid font path
-elements is built up.  Each
-.B FPE
-has a set of functions to support opening a font and accessing its
-data.
-.PP
-Font information is accessed via method functions in the 
-.B Font.
-When a font is
-first loaded, the header information and properties are
-loaded/computed.  The font also initializes its function pointers to do
-the proper work.  When specific metrics or bitmaps are required, they
-are access via the font's functions.  A disk-based bitmap font will
-probably want to load all data when first accessed.  A scaled font or
-FS font may want to do more selective caching.  In both cases, the
-renderer can use the utility functions to keep track of this data.
-Changing values of bitmap formats could result in the font having
-multiple copies of data in different formats, which the renderer may
-use the utility functions to manage.
-.NH
-Per client processing
-.PP
-Each entity attaching to the server is a client.  Each client has
-its own authorization and resolution information, and its own view
-of the font database.  A font open to one client may not be open to 
-another, though the font server may have it loaded.
-.PP
-After initialization, new clients can attach to the font server and
-have their requests processed.  For each request that is searching for
-a font
-.B (OpenBitmapFont)
-or listing font names
-.B (ListFonts,
-.B ListFontsWithXInfo),
-the pattern is given to each 
-.B FPE.
-.PP
-.B OpenBitmapFont 
-will take the supplied name and pass it to each 
-.B FPE.
-The 
-.B FPE
-will return one of three things:  
-.I Success,
-and the font object;
-.I BadFont,
-because it doesn't know the font; or 
-.I BadFont
-and an alias
-name, when it has an alias for the font.  If 
-.I Success
-is returned, the
-server goes on to create an ID (or find an existing one) and return a
-reply.  If 
-.I BadFont 
-is returned, it goes on to the next 
-.B FPE.
-If it
-reaches the end without finding a font, an error is returned to the
-client.  If an alias is returned, the search resets to the first 
-.B FPE
-and starts again, using the alias as the new font name.  This allows
-aliases to work across different 
-.B FPEs,
-without any ordering
-restrictions.
-.PP
-When each 
-.B FPE
-receives a font name to open, it searches for the font's
-existence.  If it can't find, or can only find an alias, it returns
-.I BadFont
-and any alias.  If it finds the font, it checks the
-authorization and license status of the font to that of the client.  If
-it passes, it then creates a new font object, and reads and/or computes
-at least the font's header information and properties.  (It may also
-want to produce the bitmaps and extents, but that choice is left to the
-renderer.)
-.PP
-When a font's information is accessed, the interpreter routine looks up 
-the font ID to find the font object, and then uses the font's access
-functions to get the data.  These functions will return the data in
-the format expected by the client.
-
-.NH
-Client shutdown
-.PP
-When a client disconnects, all its references to any fonts it
-still has opened are removed.  If no other clients reference these fonts, they
-may be freed, though the server may choose to cache them.
-
-.NH
-Server reset and cleanup
-.PP
-A server may be reset to flush the caches, re-read the configuration file,
-and a new list of 
-.B FPEs
-to be built, via an OS-specific outside
-action.  In UNIX, this will be handled via signals; in VMS it could be
-handled via an async trap or event flag.
-
-.NH
-Server offloading
-.PP
-In order to deal with numerous clients without major performance
-degradation, the server must be able to clone itself, or provide the
-client with a substitute server via the alternate server mechanism.
-Since both strategies have their uses, both will be supported.  For a
-server that has plenty of host memory or CPU, but insufficient sockets,
-cloning may be a good choice.  For a host with limited memory,
-assigning an alternate server on a different host may be a good
-choice.  The server will make this decision based on configuration
-options.
-
-.NH
-Font server data structures
-.LP
-.IP
-The 
-.B Client
-handles per-client information and interpreter status.
-.Ls
-typedef struct _Client {
-    int         index;
-    pointer     osPrivate;
-    int         noClientException;
-    int         (**requestVector) ();
-    pointer     requestBuffer;
-    int         clientGone;
-    int         sequence;
-    Bool        swapped;
-    long        last_request_time;
-    void        (*pSwapReplyFunc) ();
-    AuthContextPtr auth;
-    char       *catalogues;
-    int         num_catalogues;
-    Mask        eventmask;
-    fsResolution *resolutions;
-    int         num_resolutions;
-}           ClientRec, *ClientPtr;
-.Le
-.IP
-The
-.B Font
-contains basic font information, including header information and properties.
-.Ls
-typedef struct _font	{
-	int	refcount;
-	fsHeader	header;
-	fsBitmapFormat	format;
-	int	(*get_glyphs)();
-	int	(*get_metrics)();
-	int	(*get_extents)();
-	int	(*get_bitmaps)();
-	int	(*unload_font)();
-	FontPathElementPtr	fpe;
-	int	*client_ids;
-	Bool	restricted_font;
-}	FontRec *FontPtr;
-.Le
-.IP
-The
-.B ClientFont
-is a wrapper on top of 
-.B Font,
-handling client specific font information.
-.Ls
-typedef struct _clientfont {
-	FontPtr	font;
-	int	clientindex;
-}	ClientFontRec, *ClientFontRec;
-.Le
-.IP
-The
-.B AuthContext
-contains authorization information.
-.IP
-.Ls
-typedef 	struct _authcontext	{
-	char	*authname;
-	char	*authdata;
-	FSID	acid;
-}	AuthContextRec *AuthContextPtr;
-.Le
-
-.NH
-Font Path Element functions
-.PP
-These functions are associated with each renderer, and handle
-all aspects of font access.  Font data access is controlled via
-another set of functions described later.  These  functions are 
-intended to support the R5 X server as well as the font server.
-As a result, some design decisions were made to support both
-models.  When the 
-.I difs
-layer needs to access a font, it uses these functions.
-.IP
-.Ls
-typedef unsigned long	Mask;
-.sp
-typedef unsigned char	*pointer;
-.sp
-typedef struct _FontPathElement {
-    int         name_length;
-    char       *name;
-    int         type;
-    int         refcount;
-    pointer     private;
-}           FontPathElementRec, *FontPathElementPtr;
-.Le
-.PP
-The FPE's reference count is incremented when it is added to the
-current list of FPEs and when it opens a font.  It is decremented
-when it is no longer in the current list and when it closes a font.
-All reference changes are handled by the
-.I difs
-layer.  The count is required to support font catalogue changes
-that may occur while the fontserver has fonts open, and keeps FPEs
-from being lost.
-.IP
-.Ls
-.sp
-typedef struct FontNames {
-    int	nnames;
-    int	size;
-    int	*length;
-    char	**names;
-}	    FontNamesRec, *FontNamesPtr;
-.sp
-typedef struct {
-	Bool	(*name_check)();
-	int	(*init_fpe)();
-	int	(*reset_fpe)();
-	int	(*free_fpe)();
-	int	(*open_font)();
-	int	(*close_font)();
-	int	(*list_fonts)();
-	int	(*start_list_fonts_with_info)();
-	int	(*list_next_font_with_info)();
-	int	(*wakeup_fpe)();
-	int	(*client_died);
-	FontNamesPtr	renderer_names;
-} FPEFunctions;
-.sp
-int	init_fpe_type(Bool (name_func)(), 
-		int (init_func)(), int (free_func)(), int (reset_func), 
-		int (open_func)(), int (close_func)(),
-		int (list_func)(), 
-		int (start_lfwi_func)(), int (next_lfwi_func)(),
-		int (wakeup_func)(), 
-		int (client_died_func)()
-		)
-.Le
-.sp
-.LP
-This is called by the renderer when it is initialized at the beginning
-of time, and sets up
-an FPEFunctions entry for the renderer.
-.LP
-The
-.B FPEFunctions
-have the following parameters:
-.IP
-.Ls
-Bool	name_check(char *name);
-.Le
-.LP
-If 
-.I name
-is something the renderer recognizes as a valid font
-source name, it return True, otherwise False.  ie, if 
-.I name 
-is a directory name, or is prefixed by the renderer's prefix, and the
-directory contains font data the renderer can interpret, it would return
-True.
-.IP
-.Ls
-int	init_fpe(FontPathElementPtr fpe);
-.Le
-.LP
-Does any initialization work for the renderer.  The name in 
-.I fpe
-will be one whose prefix matches the list returned when the renderer
-was initialized.
-.IP
-.Ls
-int	reset_fpe(FontPathElementPtr fpe);
-.Le
-.LP
-Tells
-.I fpe
-to reset any internal state about what fonts it has available.
-This will typically be called because the font server's 
-.B FPE
-search list has been changed.  The
-.I fpe
-should reset any cached state of available fonts (ie, re-read
-.I fonts.dir) when this function is called.
-.IP
-.Ls
-int	free_fpe(FontPathElementPtr fpe);
-.Le
-.LP
-Frees any renderer-specific data and closes any files or sockets.
-.IP
-.Ls
-int	open_font(pointer client, FontPathElementPtr fpe, Mask flags, 
-		char *fontname, int namelength, 
-		fsBitmapFormat format_hint, fsBitmapFormatMask format_mask,
-		XID fontid, FontPtr *ppfont, char **alias);
-.Le
-.LP
-Opens the font.  
-The bits marked by
-.I format_mask in the
-.I format_hint
-are used where applicable.  
-The resulting FontPtr is returned in 
-.I ppfont.
-The 
-.I client 
-is optional state
-information for use with blocking renderers.  If the 
-.I fontname
- resolves to an alias, it is returned in
-.I alias
-with a 
-.I FontNameAlias
-error.  This tells the
-calling code to start searching again, using 
-.I alias
-as the font name.
-The renderer is expected to fill in any information
-specified by the 
-.I flags.
-.IP
-Possible flags values are:
-.Ls
-#define FontLoadInfo    0x0001		/* font header info */
-#define FontLoadProps   0x0002		/* font properties */
-#define FontLoadMetrics 0x0004		/* font extents */
-#define FontLoadBitmaps 0x0008		/* glyph bitmaps */
-#define FontLoadAll     0x000f
-#define FontOpenSync    0x0010		/* force synchronous loading */
-.Le
-.LP
-Once a font has been opened, the server may place it and the pattern
-it matched into a name cache, to avoid lengthy searching if the font
-is reopened.  If the renderer does not wish the font to be in this
-cache (for licensing reasons), it should set the font's
-.I restricted_access
-flag.
-.IP
-.Ls
-int	close_font(FontPtr pfont);
-.Le
-.LP
-Frees up all the data associated with the font.
-.IP
-.Ls
-int	list_fonts(pointer client, FontPathElementPtr fpe,
-		char *pattern, int pattern_length, int maxnames,
-		FontNamesPtr *paths);
-.Le
-.LP
-Returns in 
-.I paths
-up to 
-.I maxnames 
-font names the fpe recognizes as matching the given pattern.
-.IP
-.Ls
-int	start_list_fonts_with_info(pointer client,
-		FontPathElementPtr fpe, char *pattern, int pattern_length,
-		int maxnames, pointer fpe_data);
-.Le
-.LP
-Initiates a 
-.B ListFontsWithXInfo.
-Typically, a disk-based renderer
-will do the equivalent of ListFonts to gather all the font names 
-matching the pattern.  A font server renderer will send the request.
-.I fpe_data
-provides a handle for any FPE-private data that needs
-to be passed in later via 
-.B list_next_font_with_info(),
-eg, the list of font names for a disk-based renderer.
-.IP
-.Ls
-int	list_next_font_with_info(pointer client, FontPathElementPtr fpe, 
-		char **name, int *namelen, FontInfoPtr &pinfo,
-		int &num_fonts, pointer fpe_data);
-.Le
-.LP
-Returns the next font's information.  The renderer should keep any state
-it requires in the 
-.I fpe_data 
-field.  
-.I num_fonts
-contains the number
-of replies remaining.
-.LP
-These two routines are split for because of the way both disk-based
-renderers and font server renderers handle this request.
-The first function initiates the action, the second is used to gather
-the results.  For a
-disk-based renderer, a list of font names matching the pattern is first
-built up when 
-.B start_list_fonts_with_info()
-is called, and the results are gathered with each call to
-.B list_next_font_with_info.
-In a font server renderer, the first function sends the 
-.B ListFontsWithXInfo
-request, and
-the second processes the replies.
-.IP
-.Ls
-int	wakeup_fpe(FontPathElementPtr fpe, unsigned long *mask)
-.Le
-.LP
-Optional function which can be used for blocking renderers.  Typical
-usage is for a font server renderer, where it is called when a reply is
-received, allowing the data to be read and the client to be signaled
-and unblocked.
-.IP
-.Ls
-int	client_died(pointer client, FontPathElementPtr fpe)
-.Le
-.LP
-This function is called when a client dies in the middle of a blocked
-request, allowing the renderer to clean up.
-
-.NH
-Font specific functions
-.LP
-These functions are contained in each
-.B Font.
-For many renderers, every font will
-use the same functions, but some renderers may wish to use different interfaces
-for different fonts.
-.IP
-.Ls
-typedef struct {
-	INT16	left B16,
-		right B16;
-	INT16	width B16;
-	INT16	ascent B16,
-		descent B16;
-	CARD16	attributes B16;
-}	fsCharInfo;
-
-typedef struct {
-    CARD8	low,
-		high;
-}           fsChar2b;
-
-typedef struct {
-    fsChar2b	min_char,
-		max_char;
-}           fsRange;
-
-int	get_extents(pointer client,
-		FontPtr pfont, Mask flags, int num_ranges, fsRange *ranges,
-		int *num_extents, fsCharInfo **extents);
-.Le
-.LP
-Possible flags:
-.IP
-.Ls
-LoadAll		/* ignore the ranges and get everything */
-FinishRange	/* magic for range completion as specified by protocol */
-.Le
-.LP
-Builds up the requested array of extents.  The extent data (which
-the renderer allocates) is returned, as well as the number of extents.
-.I closure
-contains any blocking state information.
-.IP
-.Ls
-int	get_bitmaps(pointer client,
-		FontPtr pfont, fsBitmapFormat format, Mask flags,
-		int num_ranges, fsRange *ranges,
-		unsigned long *size, unsigned long *num_glyphs,
-		unsigned long **offsets, pointer *glyph_data);
-.Le
-.LP
-Possible flags:
-.IP
-.Ls
-LoadAll
-FinishRange	/* magic for range completion as specified by protocol */
-.Le
-.LP
-Builds up the requested array of bitmaps.  The glyph and offset data
-(which the renderer allocates) is returned, as well as the number of
-glyphs.  The 
-.I closure
-contains any blocking state information.  This function will build up the 
-bitmap data in the format specified by 
-.I format
-so that the interpreter can return it without any additional
-modification.  This should minimize data massaging, since outline
-renderers will hopefully be able to produce the bitmaps in the proper 
-format.
-.IP
-.Ls
-void	unload_font(FontPtr pfont)
-.Le
-.LP
-The render will free any allocated data.  Note that the 
-.B FPE
-function
-.B close_font()
-will also be called, and should handle any 
-.B FPE
-data allocated for the font.
-.IP
-.Ls
-int	get_glyphs()
-int	get_metrics()
-.Le
-.LP
-These two functions are used by the X server for loading glyphs and 
-metrics.  They expect the results in a considerably different
-form.  The 
-.I get_bitmaps()
-and
-.I get_extents()
-routines both allow for better cache control by the renderer.
-
-.NH
-Font directories and aliases
-.PP
-Existing bitmap renderers already have their own concept of font
-organization.  In the X sample server, the files
-.B fonts.dir
-and 
-.B fonts.alias
-are used to list the known fonts.
-.B fonts.dir
-maps file names to font names, while
-.B fonts.alias
-maps font names to other font names.
-.PP
-These concepts will also be needed by other forms of fonts
-which the sample X server does not currently use, but the font server
-will, like Bitstream outlines.
-
-.NH
-Handling scalable fonts
-.PP
-For those renderers that support scalable fonts, several issues
-must be addressed:
-.br
-.Ip
-Name Parsing.  An XLFD name must be parsed to determine the requested
-resolutions and/or sizes.
-.Ip
-Property scaling.  Many of the standard font properties have values
-that depend on scaling (eg, 
-.I RESOLUTION_X.
-.I POINT_SIZE)
-.Ip
-Default values.  If resolution information is wildcarded, the proper
-default resolution should be supplied.
-.LP
-Name Parsing
-.PP
-The font name pattern supplied to 
-.B OpenBitmapFont
-or
-.B ListFonts
-may require some parsing to be recognized as a scalable font known
-to the renderer.  The
-.B PIXEL_SIZE,
-.B POINT_SIZE,
-.B RESOLUTION_X,
-.B RESOLUTION_Y
-and
-.B AVERAGE_WIDTH
-all need to determined from the font name pattern.  The master font
-must then be found, and scaled appropriately.  Any unspecified values
-that cannot be determined should be replaced by the proper defaults.
-For size fields, this is whatever the configuration specifies.  For
-resolution fields, these should be taken from the client's resolution
-list, if set, or from the server's configuration.
-.LP
-Property scaling
-.PP
-Part of scaling a font is scaling its properties.  Many scalable fonts
-will have a very large number of scalable properties.  One way
-to deal with these is for the ``master'' outline to keep track of the 
-property names, and supply new values for each instance of the font.
-If the property names are stored as Atoms, memory usage is kept to
-a minimum.
-.LP
-Using defaults
-.PP
-Using default values as substitutions for missing values was covered above.
-These defaults will also be useful in handling 
-.B ListFonts
-requests.  Returning a scalable font with an instance using the
-default values will provide the most user-friendly environment.
-
-.NH
-Access control
-.PP
-The font server will also support large grain security.  It will have
-both a limit of the number of users, and on the hosts which it will
-support.
-.PP
-Limiting the number of users is as much a server loading issue as
-a security issue.  The limitation will be typically be set via
-configuration options or OS limitations.  To change it, use:
-.IP
-.Ls
-void	AccessSetConnectionLimit(int limit)
-.Le
-.LP
-A
-.I limit
-of 0 will set it to a compiled constant based on OS resources
-(eg, number of file descriptors).
-.PP
-Client-host based access control can be used to supplement licensing,
-and support font server load balancing by restricting access.
-As with licensing, this is OS-specific code.
-To manipulate these functions, use:
-.IP
-.Ls
-typedef struct _host_address {
-	int	type;
-	pointer	address;
-	struct _host_address *next;
-} HostAddress;
-.sp
-typedef HostAddress	*HostList;
-.sp
-int	AddHost(HostList list, HostAddress *address)
-int	RemoveHost(HostList list, HostAddress *address)
-Bool	ValidHost(HostList list, HostAddress *address)
-.Le
-.LP
-.B AddHost()
-adds a host to the
-.I list.
-.B RemoveHost()
-removes it, and
-.B ValidHost()
-checks to see if its on the
-.I list.
-In all functions, the
-.I address
-has will ignore any value in the
-.I next
-field.
-.PP
-Network addresses are used here to avoid issues with host name aliases.
-The caller fills in the desired type, and an address of that form is 
-returned.  This is highly OS-specific, but values for the
-.I type
-and
-.I address
-fields could include:
-.IP
-.Ls
-#define	HOST_AF_INET	1
-struct in_addr	*address;
-.sp
-#define	HOST_AF_DECnet	2
-struct	dn_addr	*address;
-.Le
-.LP
-The server will use a global host list, but having the list
-as an argument will allow licensing schemes to have their
-own host lists.
-
-.NH
-Licensing
-.PP
-Licensing is a tricky issue, which each renderer will support in a
-different way.  The sample font server will attempt to provide some
-guidelines, and present a possible implementation of some simple
-licensing schemes.
-.LP
-\fBHost Address licensing\fR
-.LP
-This is simplistic licensing based on the client's host.  With
-this form of licensing, a font may be accessible to some host but not
-others.  To get the current client's host, the following is used:
-.IP
-.Ls
-void	GetHostAddress(HostAddress *address);
-.Le
-.LP
-A renderer can also use the host access functions to keep a list
-of the licensed hosts, and
-.B ValidHost()
-to check a client.
-.LP
-\fBSimultaneous use license\fR
-.PP
-This licensing allows for a limited number of copies of the font to
-be open at once.  Since this should be a simple per-font counter,
-no support should be required outside of the renderer.
-
-.NH
-DIFS contents
-.PP
-This contains the protocol dispatcher, interpreter and reply encoding
-routines.
-.PP
-The interpreter is table driven off the request code.  The dispatcher
-gets a request from the os layer from 
-.B WaitForSomething(),
-and uses
-the request code to determine which function to call.  eg, a
-.I CloseFont
-request would call 
-.B ProcCloseFont().
-.PP
-Each request's routine handles any applicable error checking, and then
-does as much work as it can.  For font related requests, this means
-converting the request to the proper arguments for the renderers.
-.PP
-If any replies are generated, the reply data is gathered into the
-bytestream format, and sent via 
-.I os
-write functions to the client.
-.PP
-If the byte order of the client and server differ, the above is
-modified by having the dispatcher call an intermediate function which
-re-orders the request to the proper byte order.  Replies go through
-similar swapping.
-.LP
-\fBClient blocking\fR
-.PP
-To minimize delay caused by font server request, clients can
-be blocked while they wait for data to be produced.  This is primarily
-intended for 
-.B FPEs
-using a remote font server,
-but can be used anywhere where the font server can pause to handle
-other client requests while data needed to satisfy another is produced
-(possibly via multiple processes).
-.IP
-.Ls
-Bool	ClientSleep(ClientPtr client, Bool (*function)(), pointer closure)
-.Le
-.LP
-Puts a client to 'sleep'.  This means the client will no longer be
-considered while the server is dispatching requests.
-.I function
-will be called when the client is signaled, with the
-.I client
-and
-.I closure
-as its arguments.
-.Ls
-Bool	ClientSignal(ClientPtr client)
-.Le
-.LP
-This should be called when the client is ready to do more work.
-At this point, the function given to
-.B ClientSleep()
-will be called.
-.Ls
-void ClientWakeup(ClientPtr client)
-.Le
-.LP
-Puts the client back to its normal state processing requests.
-.Ls
-Bool ClientIsAsleep(ClientPtr client)
-.Le
-.LP
-Can be used to check if a client is asleep.  This is useful for handling
-client termination, so that any requests the client is waiting upon can be
-properply cleaned up.
-.LP
-\fBSample Usage\fR
-.PP
-For handling a font server renderer request for 
-.B OpenBitmapFont
-the renderer will send the request to the remote font server, and
-the call 
-.B ClientSleep().
-The font server will then continue processing requests from other clients,
-while the one making the request is blocked.
-When the reply returns, the renderer will notice when its
-.B wakeup_fpe()
-function is called.  At this point the font server renderer will
-read and process the reply.  
-.B ClientSignal()
-will be called, and the
-.I closure
-function will be called.  It will request the data from the renderer,
-completing the request, and call
-.B ClientWakeup()
-to return the client to normal status.
-.sp
-.PP
-This layer also contains the resource database, which associates fonts
-with IDs, extension interface functions and the server initialization
-and reset control.
-.NH
-OS contents
-.PP
-This layer contains OS specific routines for configuration, command
-line parsing, client/server communications, and various OS-dependent
-utilities such as memory management and error handling.
-.PP
-.B ReadRequestFromClient() 
-returns a full request to the dispatcher.
-.B WaitForSomething() 
-is where the server spends its idle time, waiting
-for any action from a client or processing any work left from a blocked
-client.
-.PP
-When a client attempts to connect, the server will call
-.IP
-.Ls
-int	CheckClientAuthorization(ClientPtr client, AuthPtr client_auth,
-		int *accept, int *index, int *size, char **authdata)
-.Le
-.LP
-to see if the server is set to allow the client to connect.  It may
-use licensing or configuration information to determine if the client
-can connect.
-.PP
-When then connection is established, the server will use the
-.IP
-.Ls
-typedef struct _alt_server {
-    char        subset;
-    char        namelen;
-    char       *name;
-}           AlternateServerRec, *AlternateServerPtr;
-.sp
-int ListAlternateServers(AlternateServerPtr *servers)
-.Le
-.LP
-to return any alternate server information it may have.
-.LP
-When the client limit is reached, the font server may attempt to
-copy itself, by calling
-.IP
-.Ls
-int CloneMyself()
-.Le
-.LP
-This function will (if the configuartion options allow) start a new
-font server process.  This is done in such a way that no pending 
-connections should be lost, and that the original server will accept
-no new connections.  Once the original server has no more clients, it will
-exit.
-
-Catalogue manipulation
-.PP
-Catalogues are configuration dependent, and hence sent by OS-dependent
-methods.  In order for the
-.I difs
-layer to get them, it uses
-.IP
-.Ls
-int	ListCatalogues(char *pattern, int pattern_length,
-        	int maxnames, char **catalogues, int *len)
-.Le
-.LP
-which returns the list of all catalogues it supports which match the pattern.
-This function 
-will be used by the catalogue manipulation requests, as well as by renderers
-when they give their 
-.B ListFonts
-results.
-.LP
-.Ls
-int ValidateCatalogues(int number, char *catalogues)
-.Le
-.LP
-Can be used to validate a list of catalogues, returning True if the
-list is acceptable.
-
-.NH
-Utility functions
-.LP
-Client data functions
-.PP
-These provide access to the current client's resolution and
-authorization data.  This form of interface is supplied rather than
-passing it to all renderers in the 
-.B FPE
-functions because the data may
-be complex and/or uninteresting to all renderers.
-.IP
-.Ls
-AuthContextPtr	GetClientAuthorization()
-.Le
-.LP
-Returns the authorization data for the current client.
-.IP
-.Ls
-fsResolution	*GetClientResolutions(int  *num_resolutions)
-.Le
-.LP
-Returns the list of resolutions that the current client has set.
-.sp 2
-.LP
-\fBCaching functions\fR
-.PP
-These are functions that simplify caching of renderer data.  These are 
-for use by
-renderers that take significant resources to produce data.  The data
-must be re-creatable -- the cache is not meant for general storage.
-The data may also be moved by the cache, so it should only be accessed
-by CacheID.
-.IP
-.Ls
-typedef void (*CacheFree)();
-typedef unsigned long	CacheID;
-typedef unsigned long	Cache;
-.sp 2
-Cache CacheInit(int renderer_id)
-.Le
-.LP
-Initializes a cache object for the renderer.  the returned ID should be
-passed to 
-.B CacheStoreMemory()
-when adding an object to the cache.
-.IP
-.Ls
-void CacheStats(Cache cid, unsigned long *num_entries, 
-	unsigned long *max_storage, unsigned long *current_storage,
-	unsigned long *num_lookups, unsigned long *hit_ratio)
-.Le
-.LP
-Returns statistics on the cache.  Useful if the renderer wants some
-hints about whether to place an object in the cache.  If the cache is
-nearly full, and the priority low, it may want to take different
-action.
-.IP
-.Ls
-CacheID	CacheStoreMemory(Cache cacheid, pointer data, unsigned long size, 
-			CacheFree free_func)
-.Le
-.LP
-The renderer hands the cache some chunk of contiguous memory, which the
-cache timestamps and stores.  When it needs to remove them, it calls
-the
-.I free_func,
-which must take responsibility for properly freeing the data.
-.I size
-is primarily a hint to the cache, so that cache limits can be properly
-calculated.  A return value of zero means the store failed, probably
-because the given size was over the cache limit.  If the given data is
-too large for the current cache, it will attempt to free old data to
-make room.  The returned ID is a unique value that refers both to the
-object and the cache in which it was placed.
-.IP
-.Ls
-pointer CacheFetchMemory(CacheID cid, Bool update)
-.Le
-.LP
-Returns the memory attached to the id.  If 
-.I update
-is set, the timestamp is updated.  (some accesses may wish to be 'silent',
-which allows some control over the freeing scheduling.)  If the cid is invalid,
-.I NULL
-is returned.
-.IP
-.Ls
-int	CacheFreeMemory(CacheID cid, Bool notify)
-.Le
-.LP
-Allows the cache to flush the data.  If 
-.I notify
-is set, the CacheFree
-function passed in when the data was cached will also be called.
-.IP
-.Ls
-void	MemoryFreed(CacheID cid, pointer data, int reason)
-.Le
-.LP
-Callback function from the cache to the renderer notifying it that its
-data has been flushed.  This function then has the responsibility to
-free that data.  
-.I reason
-may be one of:
-.IP
-.Ls
-CacheReset	/* all cache freed because of server reset */
-CacheEntryFreed	/* explicit request via free_memory() */
-CacheEntryOld	/* cache hit limit, and memory being freed because its old */
-.Le
-.LP
-and is supplied so that the renderer may choose how to deal with the
-free request.  (It will probably be ignored by most, but some may want to
-keep the memory around by bypassing the cache, or re-inserting it.)
-Note that the cache will consider the data gone, so it 
-.B must
-be re-inserted to keep it alive.
-.IP
-.Ls
-void	CacheSimpleFree(CacheID cid, pointer data, int reason)
-.Le
-.LP
-Just calls 
-.B free()
-on the data.  Simple CacheFree defined here to
-prevent it being redefined in each renderer.
-.PP
-Typical usage of the cache is for the renderer to store a CacheID
-rather than a pointer to the cacheable data.  The renderer is
-responsible for both allocating and freeing the data, as well as
-keeping track of just what it is.  When the renderer needs the cached
-data, it will request it from the cache.  If it fails, it must rebuild
-it.
-.PP
-A possible configuration parameter is the size of the cache.  when the
-cache is filled (with the calculation based on the given size), it
-sweeps the cache and frees old data.  The amount of memory actually
-freed may wish to be tunable:  some systems may want to keep the cache
-as full as possible, others may want to free some percentage such that
-sweeps occur less frequently.
-.PP
-Cache statistics may want to be available for administrators.  They
-could be dumped to a file when a signal is received.  (SNMP seems like
-a perfect match, but apparently the technology isn't there yet.
-.PP
-Cached data could also be compressed, if the memory/CPU tradeoffs
-make it worthwhile.
-.PP
-ISSUE:  Is a time-based freeing schedule sufficient?  Should priorities
-or size also be taken into account?  [ No.  Anything that the renderer
-thinks should have a higher priority should probably not be placed into
-the cache. ]
-.sp 2
-.LP
-\fBByte swapping\fR
-.LP
-Functions for swapping a 4-byte quantity, a 2-byte quantity and inverting
-a byte.
-.IP
-.Ls
-void	BitOrderInvert(pointer buffer, unsigned long num_bytes)
-void	TwoByteSwap(pointer buffer, unsigned long num_shorts)
-void	FourByteSwap(pointer buffer, unsigned long num_longs)
-.Le
-.LP
-\fBBitmap padding\fR
-.LP
-Functions taking a desired extents and a bitmap that will return the
-bitmap properly padded.
-.Ls
-int	RepadBitmap(pointer src, pointer dst, fsFormat src_format,
-		 fsFormat dst_format, int width, int height)
-.Le
-.LP
-Takes a bitmap in 
-.I src_format 
-and converts it to one in
-.I dst_format.
-.LP
-\fBAtoms\fR
-.PP
-Existing bitmap-based renderers use atoms to store strings for property
-information.  Rather than duplicate this code in each renderer, it
-lives in the 
-.I util
-directory.
-.PP
-Atoms will be especially useful for property information, to prevent
-many copies of the same strings from being saved.  Using atoms for
-comparison when modifying properties after scaling is also more
-efficient.  Since
-.I atoms
-will will exist until the server is reset, they may want to be used
-sparingly for property values to avoid extraneous string data.
-.IP
-.Ls
-typedef unsigned long	Atom;
-.sp
-Atom	MakeAtom(char *string, unsigned int length, Bool create)
-.Le
-.LP
-Returns the atom associated with 
-.I string.
-If
-.I create
-is true, a new atom will be created.
-.IP
-.Ls
-char	*NameForAtom(Atom atom)
-.Le
-.LP
-Returns the string associated with
-.I atom.
-
-.NH
-Server request details
-.PP
-This section describes in-depth the action of each protocol request.
-In all cases, the request is first error checked for simple length
-or value errors, with the server
-immediately returning an error if one is encountered.
-.NH 2
-Connection
-.PP
-When a new client attempts to connect, the server first checks 
-its initial authorization information to see if the server is willing
-to talk to it.  This will be handled in some OS-specific form
-using
-.B CheckClientAuthorization().
-If it passes
-this test, and the server has sufficient to resources to talk to it, the
-server sends accepts the connection and returns its connection block.
-If the connection fails, the server returns the proper status and
-a list of any alternate servers it may know of (gathered from 
-.B ListAlternateServers().)
-.NH 2
-ListExtension
-.PP
-Returns the list of extensions the server knows about.
-Any extensions will be initialized when the server is first started.
-.NH 2
-QueryExtension
-.PP
-Returns the information about the requested extension, which was set
-when the extension was initialized.
-.NH 2
-ListCatalogues
-.PP
-Returns the catalogues the server recognizes (the results of
-.B ListCatalogues().)
-.NH 2
-SetCatalogues
-.PP
-Sets the requesting client's catalogues after verifying them with the
-supported catalogues.
-.NH 2
-GetCatalogues
-.PP
-Returns the requesting client's catalogues.
-.NH 2
-CreateAC
-.PP
-Creates a new authorization context and fills it in.  The list of
-authorization protocols is then checked by the server with
-.B CheckClientAuthorization().
-If any are accepted,
-the 
-.B AC
-is placed in the resource database and
-.I Success
-is returned with the name of the accepted protocol.  If more than one is 
-accepted, 
-.I Continue
-is returned with each of the accepted protocols, until the last one
-which has status
-.I Success
-Otherwise
-.I Denied
-is returned.
-.NH 2
-FreeAC
-.PP
-Looks up the
-.B AC
-in the resource database, and frees it if it finds it.  Otherwise an
-.I Access
-error is returned.
-.NH 2
-SetAuthorization
-.PP
-Looks up the
-.B AC
-in the resource database, and set the client's AuthContextPtr
-to its value if it is found.  Otherwise it sends an 
-.I Access
-error.
-.NH 2
-SetResolution
-.PP
-Sets the requesting client's resolution list to the supplied list.
-.NH 2
-GetResolution
-.PP
-Returns the requesting client's list of resolutions.
-.NH 2
-ListFonts
-.PP
-Iterates over each open FPE, calling the FPE's
-.B list_fonts()
-routine passing it the pattern.
-When all FPE's have been processed, the list that has been built up
-is returned.  Note that the same
-.B FontNamesPtr
-is sent to each FPE in turn, so that one list is built up.
-An FPE may restrict the fonts it returns based on the client's
-catalogue.
-.NH 2
-ListFontsWithXInfo
-.PP
-Iterates over each FPE, calling its
-.B start_list_fonts_with_info()
-function to prime the FPE's renderer.  It then calls the FPE's
-.B list_next_font_with_info(),
-sending each font's data to the client until no more fonts remain.
-When all FPEs have been processed, the final reply with a zero-length
-name is then sent to mark the end of the replies.
-An FPE may restrict the fonts it returns based
-on the client's catalogue.
-Note: an issue
-exists with font aliases which may require this to change, since an FPE
-may contain an alias pointing to another FPE, and cannot therefore
-return the font's info.
-.NH 2
-OpenBitmapFont
-.PP
-The pattern is first searched for in the font server's name cache.
-If it doesn't find it, the server iterates over each FPE, calling its
-.B open_font
-function with the supplied pattern.  This will return one of the following
-values:
-.Ip
-an
-.B Access
-error, which means the renderer has the font but the client does not
-have access to it because of some form of licensing restriction
-.Ip
-a
-.B Font
-error and a NULL
-.I alias
-parameter, which will cause the next FPE to be tried
-.Ip
-a
-.B Font 
-error but a non-NULL
-.I alias,
-which will cause the search to start over with the first FPE using
-.I alias
-as the new font pattern
-.Ip
-.B Success,
-in which case a valid font has been found.
-.PP
-If the end of the FPE list is reached without having found the font,
-an error is returned to the client.  If an
-.B Access
-error was encountered, it is returned, otherwise a
-.B Font
-error is returned.
-If a valid font is found, its reference count will be incremented and
-it will be checked to see if the client has
-already opened it before.  If so, the previous ID will be returned.
-Otherwise the font will be placed in the resource database.
-.PP
-The renderer will fill in the font's header and property information,
-and may also choose to load or create the font's metrics or glyphs.
-If the glyphs are built, they will use any supplied \fIformat hint\fR.
-.PP
-Whenever a new font is successfuly opened, the font and its name pattern
-will be placed in a name cache.  This cache exists to minimize the amount 
-of work spent searching for a font.  It will be flushed when the
-font catalogue is modified.  Client's with private font catalogues
-will require private name caches.
-.NH 2
-QueryXInfo
-.PP
-The
-.I fontid
-is looked up in the resource database, and the font's header and 
-property info is returned.
-.NH 2
-QueryXExtents8 QueryXExtents16
-.PP
-The
-.I fontid
-is looked up in the resource database.  The supplied list of
-characters (interpreted according to request type) is then translated 
-into a list of ranges.  The font's 
-.B get_extents()
-function is then called.  It builds the requested list of extents,
-and returns them along with the number of extents.
-The results are properly swapped and sent to the client.
-.NH 2
-QueryXBitmaps8 QueryXBitmaps16
-.PP
-The
-.I fontid
-is looked up in the resource database.  The supplied list of
-characters (interpreted according to request type) is then translated 
-into a list of ranges.  The font's 
-.B get_bitmaps()
-function is called, and the renderer will build up the requested
-bitmaps, using the specified 
-.I format,
-and returns the bitmaps, the number of glyphs and the offsets.
-The offsets are properly swapped and the offsets and bitmaps are
-sent to the clients.
-.NH 2
-CloseFont
-.PP
-The font's reference count is decremented.  If this was the last reference,
-the font's
-.B unload_font()
-function is called to free the renderer's data, and the font's
-FPE
-.B close_font()
-function is called to free up any FPE specific data.
-
-.NH
-Configuration
-.PP
-The configuration mechanism is a simple keyword-value pair, separated 
-by an '='.  
-.LP
-Configuration types:
-.ta .6i 2.1i
-.nf
-.sp
-	cardinal	non-negative number
-.sp
-	boolean		"[Yy]es", "[Yy]" "on", "1", "[Nn]o", "[Nn]", "off", "0"
-.sp
-	resolution	\fIcardinal,cardinal\fR
-.sp
-	list of foo	1 or more of foo, separated by commas
-.sp
-.fi
-.LP
-Here is an incomplete list of the supported keywords:
-.sp
-.ta .6i 1.5i
-.nf
-#		in the first column, a comment character
-.\".sp
-.\"cache-size (cardinal) 
-.\"		Size in bytes of the FS cache.
-.sp
-catalogue (list of string)
-		Ordered list of font path element names.
-.sp
-alternate-servers (list of string)
-		List of alternate servers for this FS.
-.sp
-client-limit (cardinal)
-		Number of clients this FS will support before refusing
-		service.
-.sp
-clone-self (boolean)
-		Whether this FS should attempt to clone itself or
-		use delegates when it reachs the client-limit.
-.sp
-default-point-size (cardinal)
-		The default pointsize (in decipoints) for fonts that 
-		don't specify.
-.sp
-default-resolutions (list of resolutions)
-		Resolutions the server supports by default.
-		This information may be used as a hint for pre-rendering.
-.sp
-error-file (string)
-		Filename of the error file.  All warnings and errors
-		will be logged here.
-.sp
-port (cardinal)
-		The TCP port on which the server will listen for connections.
-.sp
-use-syslog (boolean)
-		Whether syslog(3) is to be used for errors.
-.\".sp
-.\"trusted-clients (list of string)
-.\"		Those clients the fontserver will talk to.  Others
-.\"		will be refused for the initial connection.  An empty
-.\"		list means the server will talk to any client.
-.fi
-.IP
-Each renderer may also want private configuration options.  The names
-should be prefixed by the renderer name, ie 
-.I pcf-,
-.I atm-.
-.LP
-Examples:
-.sp
-# allow a ~a megabyte of memory to be reserved for cache data
-.br
-cache-size = 1000000
-.sp
-catalogue = pcf:/usr/lib/X11/fonts/misc,speedo:/usr/lib/fonts/speedo