X Logical Font Description Conventions

X Consortium Standard

Jim Flowers

   Digital Equipment Corporation

Edited by

Stephen Gildea

   X Consortium

   X Version 11, Release 7.7

   Version 1.5

   Copyright © 1988, 1994 X Consortium

   Permission is hereby granted, free of charge, to any person
   obtaining a copy of this software and associated documentation
   files (the "Software"), to deal in the Software without
   restriction, including without limitation the rights to use,
   copy, modify, merge, publish, distribute, sublicense, and/or
   sell copies of the Software, and to permit persons to whom the
   Software is furnished to do so, subject to the following
   conditions:

   The above copyright notice and this permission notice shall be
   included in all copies or substantial portions of the Software.

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
   NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE
   FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.

   Except as contained in this notice, the name of the X
   Consortium shall not be used in advertising or otherwise to
   promote the sale, use or other dealings in this Software
   without prior written authorization from the X Consortium.

   X Window System is a trademark of The Open Group.

   Copyright © 1988, 1989 Digital Equipment Corporation, Maynard
   MA. All rights reserved.

   Permission to use, copy, modify, and distribute this
   documentation for any purpose and without fee is hereby
   granted, provided that the above copyright notice and this
   permission notice appear in all copies. Digital Equipment
   Corporation makes no representations about the suitability for
   any purpose of the information in this document. This
   documentation is provided as is without express or implied
   warranty.

   Helvetica and Times are registered trademarks of Linotype
   Company.

   ITC Avant Garde Gothic is a registered trademark of
   International Typeface Corporation.

   Times Roman is a registered trademark of Monotype Corporation.

   Bitstream Amerigo is a registered trademark of Bitstream Inc.

   Stone is a registered trademark of Adobe Systems Inc.
     __________________________________________________________

   Table of Contents

   1. Introduction
   2. Requirements and Goals

        Provide Unique and Descriptive Font Names
        Support Multiple Font Vendors and Character Sets
        Support Scalable and Polymorphic Fonts
        Support Transformations and Subsetting of Fonts
        Be Independent of X Server and Operating or File System
                Implementations

        Support Arbitrarily Complex Font Matching and Substitution
        Be Extensible

   3. X Logical Font Description

        FontName

              FontName Syntax
              FontName Field Definitions
              Examples

        Font Properties

              FOUNDRY
              FAMILY_NAME
              WEIGHT_NAME
              SLANT
              SETWIDTH_NAME
              ADD_STYLE_NAME
              PIXEL_SIZE
              POINT_SIZE
              RESOLUTION_X
              RESOLUTION_Y
              SPACING
              AVERAGE_WIDTH
              CHARSET_REGISTRY
              CHARSET_ENCODING
              MIN_SPACE
              NORM_SPACE
              MAX_SPACE
              END_SPACE
              AVG_CAPITAL_WIDTH
              AVG_LOWERCASE_WIDTH
              QUAD_WIDTH
              FIGURE_WIDTH
              SUPERSCRIPT_X
              SUPERSCRIPT_Y
              SUBSCRIPT_X
              SUBSCRIPT_Y
              SUPERSCRIPT_SIZE
              SUBSCRIPT_SIZE
              SMALL_CAP_SIZE
              UNDERLINE_POSITION
              UNDERLINE_THICKNESS
              STRIKEOUT_ASCENT
              STRIKEOUT_DESCENT
              ITALIC_ANGLE
              CAP_HEIGHT
              X_HEIGHT
              RELATIVE_SETWIDTH
              RELATIVE_WEIGHT
              WEIGHT
              RESOLUTION
              FONT
              FACE_NAME
              FULL_NAME
              COPYRIGHT
              NOTICE
              DESTINATION
              FONT_TYPE
              FONT_VERSION
              RASTERIZER_NAME
              RASTERIZER_VERSION
              RAW_ASCENT
              RAW_DESCENT
              RAW_*
              AXIS_NAMES
              AXIS_LIMITS
              AXIS_TYPES

        Built-in Font Property Atoms

   4. Matrix Transformations

        Metrics and Font Properties

   5. Scalable Fonts
   6. Polymorphic Fonts
   7. Affected Elements of Xlib and the X Protocol
   8. BDF Conformance

        XLFD Conformance Requirements
        FONT_ASCENT, FONT_DESCENT, and DEFAULT_CHAR

              FONT_ASCENT
              FONT_DESCENT
              DEFAULT_CHAR

Chapter 1. Introduction

   It is a requirement that X client applications must be portable
   across server implementations, with very different file
   systems, naming conventions, and font libraries. However, font
   access requests, as defined by the X Window System Protocol,
   neither specify server-independent conventions for font names
   nor provide adequate font properties for logically describing
   typographic fonts.

   X clients must be able to dynamically determine the fonts
   available on any given server so that understandable
   information can be presented to the user or so that intelligent
   font fallbacks can be chosen. It is desirable for the most
   common queries to be accomplished without the overhead of
   opening each font and inspecting font properties, by means of
   simple ListFonts requests. For example, if a user selected a
   Helvetica typeface family, a client application should be able
   to query the server for all Helvetica fonts and present only
   those setwidths, weights, slants, point sizes, and character
   sets available for that family.

   This document gives a standard logical font description
   (hereafter referred to as XLFD) and the conventions to be used
   in the core protocol so that clients can query and access
   screen type libraries in a consistent manner across all X
   servers. In addition to completely specifying a given font by
   means of its FontName, the XLFD also provides for a standard
   set of key FontProperties that describe the font in more
   detail.

   The XLFD provides an adequate set of typographic font
   properties, such as CAP_HEIGHT, X_HEIGHT, and
   RELATIVE_SETWIDTH, for publishing and other applications to do
   intelligent font matching or substitution when handling
   documents created on some foreign server that use potentially
   unknown fonts. In addition, this information is required by
   certain clients to position subscripts automatically and
   determine small capital heights, recommended leading,
   word-space values, and so on.

Chapter 2. Requirements and Goals

   Table of Contents

   Provide Unique and Descriptive Font Names
   Support Multiple Font Vendors and Character Sets
   Support Scalable and Polymorphic Fonts
   Support Transformations and Subsetting of Fonts
   Be Independent of X Server and Operating or File System
          Implementations

   Support Arbitrarily Complex Font Matching and Substitution
   Be Extensible

   The XLFD meets the short-term and long-term goals to have a
   standard logical font description that:
     * Provides unique, descriptive font names that support simple
       pattern matching
     * Supports multiple font vendors, arbitrary character sets,
       and encodings
     * Supports naming and instancing of scalable and polymorphic
       fonts
     * Supports transformations and subsetting of fonts
     * Is independent of X server and operating or file system
       implementations
     * Supports arbitrarily complex font matching or substitution
     * Is extensible

Provide Unique and Descriptive Font Names

   It should be possible to have font names that are long enough
   and descriptive enough to have a reasonable probability of
   being unique without inventing a new registration organization.
   Resolution and size-dependent font masters, multivendor font
   libraries, and so on must be anticipated and handled by the
   font name alone.

   The name itself should be structured to be amenable to simple
   pattern matching and parsing, thus allowing X clients to
   restrict font queries to some subset of all possible fonts in
   the server.

Support Multiple Font Vendors and Character Sets

   The font name and properties should distinguish between fonts
   that were supplied by different font vendors but that possibly
   share the same name. We anticipate a highly competitive font
   market where users will be able to buy fonts from many sources
   according to their particular requirements.

   A number of font vendors deliver each font with all glyphs
   designed for that font, where charset mappings are defined by
   encoding vectors. Some server implementations may force these
   mappings to proprietary or standard charsets statically in the
   font data. Others may desire to perform the mapping dynamically
   in the server. Provisions must be made in the font name that
   allows a font request to specify or identify specific charset
   mappings in server environments where multiple charsets are
   supported.

Support Scalable and Polymorphic Fonts

   If a font source can be scaled to an arbitrary size or varied
   in other ways, it should be possible for an application to
   determine that fact from the font name, and the application
   should be able to construct a font name for any specific
   instance.

Support Transformations and Subsetting of Fonts

   Arbitrary two-dimensional linear transformations of fonts
   should be able to be requested by applications. Since such
   transformed fonts may be used for special effects requiring a
   few characters from each of many differently transformed fonts,
   it should be possible to request only a few characters from a
   font for efficiency.

Be Independent of X Server and Operating or File System
Implementations

   X client applications that require a particular font should be
   able to use the descriptive name without knowledge of the file
   system or other repository in use by the server. However, it
   should be possible for servers to translate a given font name
   into a file name syntax that it knows how to deal with, without
   compromising the uniqueness of the font name. This algorithm
   should be reversible (exactly how this translation is done is
   implementation dependent).

Support Arbitrarily Complex Font Matching and Substitution

   In addition to the font name, the XLFD should define a standard
   list of descriptive font properties, with agreed-upon fallbacks
   for all fonts. This allows client applications to derive
   font-specific formatting or display data and to perform font
   matching or substitution when asked to handle potentially
   unknown fonts, as required.

Be Extensible

   The XLFD must be extensible so that new and/or private
   descriptive font properties can be added to conforming fonts
   without making existing X client or server implementations
   obsolete.

Chapter 3. X Logical Font Description

   Table of Contents

   FontName

        FontName Syntax
        FontName Field Definitions
        Examples

   Font Properties

        FOUNDRY
        FAMILY_NAME
        WEIGHT_NAME
        SLANT
        SETWIDTH_NAME
        ADD_STYLE_NAME
        PIXEL_SIZE
        POINT_SIZE
        RESOLUTION_X
        RESOLUTION_Y
        SPACING
        AVERAGE_WIDTH
        CHARSET_REGISTRY
        CHARSET_ENCODING
        MIN_SPACE
        NORM_SPACE
        MAX_SPACE
        END_SPACE
        AVG_CAPITAL_WIDTH
        AVG_LOWERCASE_WIDTH
        QUAD_WIDTH
        FIGURE_WIDTH
        SUPERSCRIPT_X
        SUPERSCRIPT_Y
        SUBSCRIPT_X
        SUBSCRIPT_Y
        SUPERSCRIPT_SIZE
        SUBSCRIPT_SIZE
        SMALL_CAP_SIZE
        UNDERLINE_POSITION
        UNDERLINE_THICKNESS
        STRIKEOUT_ASCENT
        STRIKEOUT_DESCENT
        ITALIC_ANGLE
        CAP_HEIGHT
        X_HEIGHT
        RELATIVE_SETWIDTH
        RELATIVE_WEIGHT
        WEIGHT
        RESOLUTION
        FONT
        FACE_NAME
        FULL_NAME
        COPYRIGHT
        NOTICE
        DESTINATION
        FONT_TYPE
        FONT_VERSION
        RASTERIZER_NAME
        RASTERIZER_VERSION
        RAW_ASCENT
        RAW_DESCENT
        RAW_*
        AXIS_NAMES
        AXIS_LIMITS
        AXIS_TYPES

   Built-in Font Property Atoms

   XLFD is divided into two basic components: the FontName, which
   gives all font information needed to uniquely identify a font
   in X protocol requests (for example, OpenFont, ListFonts, and
   so on) and a variable list of optional FontProperties, which
   describe a font in more detail.

   The FontName is used in font queries and is returned as data in
   certain X protocol requests. It is also specified as the data
   value for the FONT item in the X Consortium Character Bitmap
   Distribution Format Standard (BDF V2.1).

   The FontProperties are supplied on a font-by-font basis and are
   returned as data in certain X protocol requests as part of the
   XFontStruct data structure. The names and associated data
   values for each of the FontProperties may also appear as items
   of the STARTPROPERTIES...ENDPROPERTIESlist in the BDF V2.1
   specification.

FontName

   Each FontName is logically composed of two strings: a
   FontNameRegistry prefix that is followed by a FontNameSuffix.
   The FontName uses the ISO 8859-1 encoding. The FontNameRegistry
   is an x-registered-name (a name that has been registered with
   the X Consortium) that identifies the registration authority
   that owns the specified FontNameSuffix syntax and semantics.

   All font names that conform to this specification are to use a
   FontNameRegistry prefix, which is defined to be the string "-"
   (HYPHEN). All FontNameRegistry prefixes of the form: +version-,
   where the specified version indicates some future XLFD
   specification, are reserved by the X Consortium for future
   extensions to XLFD font names. If required, extensions to the
   current XLFD font name shall be constructed by appending new
   fields to the current structure, each delimited by the existing
   field delimiter. The availability of other FontNameRegistry
   prefixes or fonts that support other registries is server
   implementation dependent.

   In the X protocol specification, the FontName is required to be
   a string; hence, numeric field values are represented in the
   name as string equivalents. All FontNameSuffix fields are also
   defined as FontProperties; numeric property values are
   represented as signed or unsigned integers, as appropriate.

FontName Syntax

   The FontName is a structured, parsable string (of type STRING8)
   whose Backus-Naur Form syntax description is as follows:
   FontName ::= XFontNameRegistry XFontNameSuffix |
   PrivFontNameRegistry PrivFontNameSuffix
   XFontNameRegistry ::= XFNDelim | XFNExtPrefix Version XFNDelim
   XFontNameSuffix ::= FOUNDRY XFNDelim FAMILY_NAME XFNDelim
   WEIGHT_NAME XFNDelim SLANT XFNDelim SETWIDTH_NAME XFNDelim
   ADD_STYLE_NAME XFNDelim PIXEL_SIZE XFNDelim POINT_SIZE XFNDelim
   RESOLUTION_X XFNDelim RESOLUTION_Y XFNDelim SPACING XFNDelim
   AVERAGE_WIDTH XFNDelim CHARSET_REGISTRY XFNDelim
   CHARSET_ENCODING
   Version ::= STRING8 - the XLFD version that defines an
   extension to the font name syntax (for example, "1.4")
   XFNExtPrefix ::= OCTET - "+" (PLUS)
   XFNDelim ::= OCTET - "-" (HYPHEN)
   PrivFontNameRegistry ::= STRING8 - other than those strings
   reserved by XLFD
   PrivFontNameSuffix ::= STRING8

   Field values are constructed as strings of ISO 8859-1 graphic
   characters, excluding the following:
     * '-' (HYPHEN), the XLFD font name delimiter character
     * '?' (QUESTION MARK) and "*" (ASTERISK), the X protocol font
       name wildcard characters
     * ',' (COMMA), used by Xlib to separate XLFD font names in a
       font set.
     * '"' (QUOTATION MARK), used by some commercial products to
       quote a font name.

   Alphabetic case distinctions are allowed but are for human
   readability concerns only. Conforming X servers will perform
   matching on font name query or open requests independent of
   case. The entire font name string must have no more than 255
   characters. It is recommended that clients construct font name
   query patterns by explicitly including all field delimiters to
   avoid unexpected results. Note that SPACE is a valid character
   of a FontName field; for example, the string "ITC Avant Garde
   Gothic" might be a FAMILY_NAME.

FontName Field Definitions

   This section discusses the FontName:
     * FOUNDRY field
     * FAMILY_NAME field
     * WEIGHT_NAME field
     * SLANT field
     * SETWIDTH_NAME field
     * ADD_STYLE_NAME field
     * PIXEL_SIZE field
     * POINT_SIZE field
     * RESOLUTION_X and RESOLUTION_Y fields
     * SPACING field
     * AVERAGE_WIDTH field
     * CHARSET_REGISTRY and CHARSET_ENCODING fields

FOUNDRY Field

   FOUNDRY is an x-registered-name, the name or identifier of the
   digital type foundry that digitized and supplied the font data,
   or if different, the identifier of the organization that last
   modified the font shape or metric information.

   The reason this distinction is necessary is that a given font
   design may be licensed from one source (for example, ITC) but
   digitized and sold by any number of different type suppliers.
   Each digital version of the original design, in general, will
   be somewhat different in metrics and shape from the idealized
   original font data, because each font foundry, for better or
   for worse, has its own standards and practices for tweaking a
   typeface for a particular generation of output technologies or
   has its own perception of market needs.

   It is up to the type supplier to register with the X Consortium
   a suitable name for this FontName field according to the
   registration procedures defined by the Consortium.

   The X Consortium shall define procedures for registering
   foundry and other names and shall maintain and publish, as part
   of its public distribution, a registry of such registered names
   for use in XLFD font names and properties.

FAMILY_NAME Field

   FAMILY_NAME is a string that identifies the range or family of
   typeface designs that are all variations of one basic
   typographic style. This must be spelled out in full, with words
   separated by spaces, as required. This name must be
   human-understandable and suitable for presentation to a font
   user to identify the typeface family.

   It is up to the type supplier to supply and maintain a suitable
   string for this field and font property, to secure the proper
   legal title to a given name, and to guard against the
   infringement of other's copyrights or trademarks. By
   convention, FAMILY_NAME is not translated. FAMILY_NAME may
   include an indication of design ownership if considered a valid
   part of the typeface family name.

   The following are examples of FAMILY_NAME:
     * Helvetica
     * ITC Avant Garde Gothic
     * Times
     * Times Roman
     * Bitstream Amerigo
     * Stone

WEIGHT_NAME Field

   WEIGHT_NAME is a string that identifies the font's typographic
   weight, that is, the nominal blackness of the font, according
   to the FOUNDRY's judgment. This name must be
   human-understandable and suitable for presentation to a font
   user. The value "0" is used to indicate a polymorphic font (see
   Polymorphic Fonts).

   The interpretation of this field is somewhat problematic
   because the typographic judgment of weight has traditionally
   depended on the overall design of the typeface family in
   question; that is, it is possible that the DemiBold weight of
   one font could be almost equivalent in typographic feel to a
   Bold font from another family.

   WEIGHT_NAME is captured as an arbitrary string because it is an
   important part of a font's complete human-understandable name.
   However, it should not be used for font matching or
   substitution. For this purpose, X client applications should
   use the weight-related font properties (RELATIVE_WEIGHT and
   WEIGHT) that give the coded relative weight and the calculated
   weight, respectively.

SLANT Field

   SLANT is a code-string that indicates the overall posture of
   the typeface design used in the font. The encoding is as
   follows:
   Code English Translation Description
   "R" Roman Upright design
   "I" Italic Italic design, slanted clockwise from the vertical
   "O" Oblique Obliqued upright design, slanted clockwise from the
   vertical
   "RI" Reverse Italic Italic design, slanted counterclockwise
   from the vertical
   "RO" Reverse Oblique Obliqued upright design, slanted
   counterclockwise from the vertical
   "OT" Other Other
   numeric Polymorphic See Polymorphic Fonts.

   The SLANT codes are for programming convenience only and
   usually are converted into their equivalent
   human-understandable form before being presented to a user.

SETWIDTH_NAME Field

   SETWIDTH_NAME is a string that gives the font's typographic
   proportionate width, that is, the nominal width per horizontal
   unit of the font, according to the FOUNDRY's judgment. The
   value "0" is used to indicate a polymorphic font (see
   Polymorphic Fonts).

   As with WEIGHT_NAME, the interpretation of this field or font
   property is somewhat problematic, because the designer's
   judgment of setwidth has traditionally depended on the overall
   design of the typeface family in question. For purposes of font
   matching or substitution, X client applications should either
   use the RELATIVE_SETWIDTH font property that gives the relative
   coded proportionate width or calculate the proportionate width.

   The following are examples of SETWIDTH_NAME:
     * Normal
     * Condensed
     * Narrow
     * Double Wide

ADD_STYLE_NAME Field

   ADD_STYLE_NAME is a string that identifies additional
   typographic style information that is not captured by other
   fields but is needed to identify the particular font. The
   character "[" anywhere in the field is used to indicate a
   polymorphic font (see Polymorphic Fonts).

   ADD_STYLE_NAME is not a typeface classification field and is
   only used for uniqueness. Its use, as such, is not limited to
   typographic style distinctions.

   The following are examples of ADD_STYLE_NAME:
     * Serif
     * Sans Serif
     * Informal
     * Decorated

PIXEL_SIZE Field

   PIXEL_SIZE gives the body size of the font at a particular
   POINT_SIZE and RESOLUTION_Y. PIXEL_SIZE is either an
   integer-string or a string beginning with "[". A string
   beginning with "[" represents a matrix (see Matrix
   Transformations). PIXEL_SIZE usually incorporates additional
   vertical spacing that is considered part of the font design.
   (Note, however, that this value is not necessarily equivalent
   to the height of the font bounding box.) Zero is used to
   indicate a scalable font (see Scalable Fonts).

   PIXEL_SIZE usually is used by X client applications that need
   to query fonts according to device-dependent size, regardless
   of the point size or vertical resolution for which the font was
   designed.

SN POINT_SIZE Field

   POINT_SIZE gives the body size for which the font was designed.
   POINT_SIZE is either an integer-string or a string beginning
   with "[". A string beginning with "[" represents a matrix (see
   Matrix Transformations). This field usually incorporates
   additional vertical spacing that is considered part of the font
   design. (Note, however, that POINT_SIZE is not necessarily
   equivalent to the height of the font bounding box.) POINT_SIZE
   is expressed in decipoints (where points are as defined in the
   X protocol or 72.27 points equal 1 inch). Zero is used to
   indicate a scalable font (see Scalable Fonts).

   POINT_SIZE and RESOLUTION_Y are used by X clients to query
   fonts according to device-independent size to maintain constant
   text size on the display regardless of the PIXEL_SIZE used for
   the font.

RESOLUTION_X and RESOLUTION_Y Fields

   RESOLUTION_X and RESOLUTION_Y are unsigned integer-strings that
   give the horizontal and vertical resolution, measured in pixels
   or dots per inch (dpi), for which the font was designed. Zero
   is used to indicate a scalable font (see Scalable Fonts).
   Horizontal and vertical values are required because a separate
   bitmap font must be designed for displays with very different
   aspect ratios (for example, 1:1, 4:3, 2:1, and so on).

   The separation of pixel or point size and resolution is
   necessary because X allows for servers with very different
   video characteristics (for example, horizontal and vertical
   resolution, screen and pixel size, pixel shape, and so on) to
   potentially access the same font library. The font name, for
   example, must differentiate between a 14-point font designed
   for 75 dpi (body size of about 14 pixels) or a 14-point font
   designed for 150 dpi (body size of about 28 pixels). Further,
   in servers that implement some or all fonts as continuously
   scaled and scan-converted outlines, POINT_SIZE and RESOLUTION_Y
   will help the server to differentiate between potentially
   separate font masters for text, title, and display sizes or for
   other typographic considerations.

SPACING Field

   SPACING is a code-string that indicates the escapement class of
   the font, that is, monospace (fixed pitch), proportional
   (variable pitch), or charcell (a special monospaced font that
   conforms to the traditional data-processing character cell font
   model). The encoding is as follows:
   Code English Translation Description
   "P" Proportional A font whose logical character widths vary for
   each glyph. Note that no other restrictions are placed on the
   metrics of a proportional font.
   "M" Monospaced A font whose logical character widths are
   constant (that is, every glyph in the font has the same logical
   width). No other restrictions are placed on the metrics of a
   monospaced font.
   "C" CharCell A monospaced font that follows the standard
   typewriter character cell model (that is, the glyphs of the
   font can be modeled by X clients as "boxes" of the same width
   and height that are imaged side-by-side to form text strings or
   top-to-bottom to form text lines). By definition, all glyphs
   have the same logical character width, and no glyphs have "ink"
   outside of the character cell. There is no kerning (that is, on
   a per-character basis with positive metrics: 0 <= left-bearing
   <= right-bearing <= width; with negative metrics: width <=
   left-bearing <= right-bearing <= zero). Also, the vertical
   extents of the font do not exceed the vertical spacing (that
   is, on a per-character basis: ascent <= font-ascent and descent
   <= font-descent). The cell height = font-descent + font-ascent,
   and the width = AVERAGE_WIDTH.

AVERAGE_WIDTH Field

   AVERAGE_WIDTH is an integer-string typographic metric value
   that gives the unweighted arithmetic mean of the absolute value
   of the width of each glyph in the font (measured in tenths of
   pixels), multiplied by -1 if the dominant writing direction for
   the font is right-to-left. A leading "~" (TILDE) indicates a
   negative value. For monospaced and character cell fonts, this
   is the width of all glyphs in the font. Zero is used to
   indicate a scalable font (see Scalable Fonts).

CHARSET_REGISTRY and CHARSET_ENCODING Fields

   The character set used to encode the glyphs of the font (and
   implicitly the font's glyph repertoire), as maintained by the X
   Consortium character set registry. CHARSET_REGISTRY is an
   x-registered-name that identifies the registration authority
   that owns the specified encoding. CHARSET_ENCODING is a
   registered name that identifies the coded character set as
   defined by that registration authority and, optionally, a
   subsetting hint.

   Although the X protocol does not explicitly have any knowledge
   about character set encodings, it is expected that server
   implementors will prefer to embed knowledge of certain
   proprietary or standard charsets into their font library for
   reasons of performance and convenience. The CHARSET_REGISTRY
   and CHARSET_ENCODING fields or properties allow an X client
   font request to specify a specific charset mapping in server
   environments where multiple charsets are supported. The
   availability of any particular character set is font and server
   implementation dependent.

   To prevent collisions when defining character set names, it is
   recommended that CHARSET_REGISTRY and CHARSET_ENCODING name
   pairs be constructed according to the following conventions:
   CharsetRegistry ::= StdCharsetRegistryName |
   PrivCharsetRegistryName
   CharsetEncoding ::= StdCharsetEncodingName |
   PrivCharsetEncodingName
   StdCharsetRegistryName ::= StdOrganizationId StdNumber |
   StdOrganizationId StdNumber Dot Year
   PrivCharsetRegistryName ::= OrganizationId STRING8
   StdCharsetEncodingName ::= STRING8-numeric part number of
   referenced standard
   PrivCharsetEncodingName ::= STRING8
   StdOrganizationId ::= STRING8-the registered name or acronym of
   the referenced standard organization
   StdNumber ::= STRING8-referenced standard number
   OrganizationId ::= STRING8-the registered name or acronym of
   the organization
   Dot ::= OCTET-"." (FULL STOP)
   Year ::= STRING8-numeric year (for example, 1989)

   The X Consortium shall maintain and publish a registry of such
   character set names for use in X protocol font names and
   properties as specified in XLFD.

   The ISO Latin-1 character set shall be registered by the X
   Consortium as the CHARSET_REGISTRY-CHARSET_ENCODING value pair:
   "ISO8859-1".

   If the CHARSET_ENCODING contains a "[" (LEFT SQUARE BRACKET),
   the "[" and the characters after it up to a "]" (RIGHT SQUARE
   BRACKET) are a subsetting hint telling the font source that the
   client is interested only in a subset of the characters of the
   font. The font source can, optionally, return a font that
   contains only those characters or any superset of those
   characters. The client can expect to obtain valid glyphs and
   metrics only for those characters, and not for any other
   characters in the font. The font properties may optionally be
   calculated by considering only the characters in the subset.

   The BNF for the subsetting hint is
   Subset ::= LeftBracket RangeList RightBracket
   RangeList ::= Range | Range Space RangeList
   Range ::= Number | Number Underscore Number
   Number ::= "0x" HexNumber | DecNumber
   HexNumber ::= HexDigit | HexDigit HexNumber
   DecNumber ::= DecDigit | DecDigit DecNumber
   DecDigit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" |
   "8" | "9"
   HexDigit ::= DecDigit | "a" | "b" | "c" | "d" | "e" | "f"
   LeftBracket ::= "[" (LEFT SQUARE BRACKET)
   RightBracket ::= "]" (RIGHT SQUARE BRACKET)
   Space ::= "\0" (SPACE)
   Underscore ::= "_" (LOW LINE)

   Each Range specifies characters that are to be part of the
   subset included in the font. A Range containing two Numbers
   specifies the first and last character, inclusively, of a range
   of characters. A Range that is a single Number specifies a
   single character to be included in the font. A HexNumber is
   interpreted as a hexadecimal number. A DecNumber is interpreted
   as a decimal number. The font consists of the union of all the
   Ranges in the RangeList.

   For example,
     -misc-fixed-medium-r-normal--0-0-0-0-c-0-iso8859-1[65 70 80_90]

   tells the font source that the client is interested only in
   characters 65, 70, and 80-90.

Examples

   The following examples of font names are derived from the
   screen fonts shipped with the X Consortium distribution.
   Font                       X FontName
   75-dpi Fonts
   Charter 12 pt
   -Bitstream-Charter-Medium-R-Normal--12-120-75-75-P-68-ISO8859-1
   Charter Bold 12 pt
   -Bitstream-Charter-Bold-R-Normal--12-120-75-75-P-76-ISO8859-1
   Charter Bold Italic 12 pt
   -Bitstream-Charter-Bold-I-Normal--12-120-75-75-P-75-ISO8859-1
   Charter Italic 12 pt
   -Bitstream-Charter-Medium-I-Normal--12-120-75-75-P-66-ISO8859-1
   Courier 8 pt
   -Adobe-Courier-Medium-R-Normal--8-80-75-75-M-50-ISO8859-1
   Courier 10 pt
   -Adobe-Courier-Medium-R-Normal--10-100-75-75-M-60-ISO8859-1
   Courier 12 pt
   -Adobe-Courier-Medium-R-Normal--12-120-75-75-M-70-ISO8859-1
   Courier 24 pt
   -Adobe-Courier-Medium-R-Normal--24-240-75-75-M-150-ISO8859-1
   Courier Bold 10 pt
   -Adobe-Courier-Bold-R-Normal--10-100-75-75-M-60-ISO8859-1
   Courier Bold Oblique 10 pt
   -Adobe-Courier-Bold-O-Normal--10-100-75-75-M-60-ISO8859-1
   Courier Oblique 10 pt
   -Adobe-Courier-Medium-O-Normal--10-100-75-75-M-60-ISO8859-1
   100-dpi Fonts
   Symbol 10 pt
   -Adobe-Symbol-Medium-R-Normal--14-100-100-100-P-85-Adobe-FONTSP
   ECIFIC
   Symbol 14 pt
   -Adobe-Symbol-Medium-R-Normal--20-140-100-100-P-107-Adobe-FONTS
   PECIFIC
   Symbol 18 pt
   -Adobe-Symbol-Medium-R-Normal--25-180-100-100-P-142-Adobe-FONTS
   PECIFIC
   Symbol 24 pt
   -Adobe-Symbol-Medium-R-Normal--34-240-100-100-P-191-Adobe-FONTS
   PECIFIC
   Times Bold 10 pt
   -Adobe-Times-Bold-R-Normal--14-100-100-100-P-76-ISO8859-1
   Times Bold Italic 10 pt
   -Adobe-Times-Bold-I-Normal--14-100-100-100-P-77-ISO8859-1
   Times Italic 10 pt
   -Adobe-Times-Medium-I-Normal--14-100-100-100-P-73-ISO8859-1
   Times Roman 10 pt
   -Adobe-Times-Medium-R-Normal--14-100-100-100-P-74-ISO8859-1

Font Properties

   All font properties are optional but will generally include the
   font name fields and, on a font-by-font basis, any other useful
   font descriptive and use information that may be required to
   use the font intelligently. The XLFD specifies an extensive set
   of standard X font properties, their interpretation, and
   fallback rules when the property is not defined for a given
   font. The goal is to provide client applications with enough
   font information to be able to make automatic formatting and
   display decisions with good typographic results.

   Font property names use the ISO 8859-1 encoding.

   Additional standard X font property definitions may be defined
   in the future and private properties may exist in X fonts at
   any time. Private font properties should be defined to conform
   to the general mechanism defined in the X protocol to prevent
   overlap of name space and ambiguous property names, that is,
   private font property names are of the form: "_" (LOW LINE),
   followed by the organizational identifier, followed by "_" (LOW
   LINE), and terminated with the property name.

   The Backus-Naur Form syntax description of X font properties is
   as follows:
   Properties ::= OptFontPropList
   OptFontPropList ::= NULL | OptFontProp OptFontPropList
   OptFontProp ::= PrivateFontProp | XFontProp
   PrivateFontProp ::= STRING8 | Underscore OrganizationId
   Underscore STRING8
   XFontProp ::= FOUNDRY | FAMILY_NAME | WEIGHT_NAME | SLANT |
   SETWIDTH_NAME | ADD_STYLE_NAME | PIXEL_SIZE | POINT_SIZE |
   RESOLUTION_X | RESOLUTION_Y | SPACING | AVERAGE_WIDTH |
   CHARSET_REGISTRY | CHARSET_ENCODING | QUAD_WIDTH | RESOLUTION |
   MIN_SPACE | NORM_SPACE | MAX_SPACE | END_SPACE | SUPERSCRIPT_X
   | SUPERSCRIPT_Y | SUBSCRIPT_X | SUBSCRIPT_Y |
   UNDERLINE_POSITION | UNDERLINE_THICKNESS | STRIKEOUT_ASCENT |
   STRIKEOUT_DESCENT | ITALIC_ANGLE | X_HEIGHT | WEIGHT |
   FACE_NAME | FULL_NAME | FONT | COPYRIGHT | AVG_CAPITAL_WIDTH |
   AVG_LOWERCASE_WIDTH | RELATIVE_SETWIDTH | RELATIVE_WEIGHT |
   CAP_HEIGHT | SUPERSCRIPT_ SIZE | FIGURE_WIDTH | SUBSCRIPT_SIZE
   | SMALL_CAP_SIZE | NOTICE | DESTINATION | FONT_TYPE |
   FONT_VERSION | RASTERIZER_NAME | RASTERIZER_VERSION |
   RAW_ASCENT | RAW_DESCENT | RAW_* | AXIS_NAMES | AXIS_LIMITS |
   AXIS_TYPES
   Underscore ::= OCTET-"_" (LOW LINE)
   OrganizationId ::= STRING8-the registered name of the
   organization

FOUNDRY

   FOUNDRY is as defined in the FontName except that the property
   type is ATOM.

   FOUNDRY cannot be calculated or defaulted if not supplied as a
   font property.

FAMILY_NAME

   FAMILY_NAME is as defined in the FontName except that the
   property type is ATOM.

   FAMILY_NAME cannot be calculated or defaulted if not supplied
   as a font property.

WEIGHT_NAME

   WEIGHT_NAME is as defined in the FontName except that the
   property type is ATOM.

   WEIGHT_NAME can be defaulted if not supplied as a font
   property, as follows:
if (WEIGHT_NAME undefined) then
   WEIGHT_NAME = ATOM("Medium")

SLANT

   SLANT is as defined in the FontName except that the property
   type is ATOM.

   SLANT can be defaulted if not supplied as a font property, as
   follows:
if (SLANT undefined) then
   SLANT = ATOM("R")

SETWIDTH_NAME

   SETWIDTH_NAME is as defined in the FontName except that the
   property type is ATOM.

   SETWIDTH_NAME can be defaulted if not supplied as a font
   property, as follows:
if (SETWIDTH_NAME undefined) then
   SETWIDTH_NAME = ATOM("Normal")

ADD_STYLE_NAME

   ADD_STYLE_NAME is as defined in the FontName except that the
   property type is ATOM.

   ADD_STYLE_NAME can be defaulted if not supplied as a font
   property, as follows:
if (ADD_STYLE_NAME undefined) then
   ADD_STYLE_NAME = ATOM("")

PIXEL_SIZE

   PIXEL_SIZE is as defined in the FontName except that the
   property type is INT32.

   X clients requiring pixel values for the various typographic
   fixed spaces (em space, en space, and thin space) can use the
   following algorithm for computing these values from other
   properties specified for a font:
     DeciPointsPerInch = 722.7
     EMspace = ROUND ((RESOLUTION_X * POINT_SIZE) / DeciPointsPerInch)
     ENspace = ROUND (EMspace / 2)
     THINspace = ROUND (EMspace / 3)\fP

   where a slash (/) denotes real division, an asterisk (*)
   denotes real multiplication, and ROUND denotes a function that
   rounds its real argument a up or down to the next integer. This
   rounding is done according to X = FLOOR ( a + 0.5), where FLOOR
   is a function that rounds its real argument down to the nearest
   integer.

   PIXEL_SIZE can be approximated if not supplied as a font
   property, according to the following algorithm:
DeciPointsPerInch = 722.7
if (PIXEL_SIZE undefined) then
   PIXEL_SIZE = ROUND ((RESOLUTION_Y * POINT_SIZE) / DeciPointsPerInch)

POINT_SIZE

   POINT_SIZE is as defined in the FontName except that the
   property type is INT32.

   X clients requiring device-independent values for em space, en
   space, and thin space can use the following algorithm:
     EMspace = ROUND (POINT_SIZE / 10)
     ENspace = ROUND (POINT_SIZE / 20)
     THINspace = ROUND (POINT_SIZE / 30)

   Design POINT_SIZE cannot be calculated or approximated.

RESOLUTION_X

   RESOLUTION_X is as defined in the FontName except that the
   property type is CARD32.

   RESOLUTION_X cannot be calculated or approximated.

RESOLUTION_Y

   RESOLUTION_Y is as defined in the FontName except that the
   property type is CARD32.

   RESOLUTION_X cannot be calculated or approximated.

SPACING

   SPACING is as defined in the FontName except that the property
   type is ATOM.

   SPACING can be calculated if not supplied as a font property,
   according to the definitions given above for the FontName.

AVERAGE_WIDTH

   AVERAGE_WIDTH is as defined in the FontName except that the
   property type is INT32.

   AVERAGE_WIDTH can be calculated if not provided as a font
   property, according to the following algorithm:
if (AVERAGE_WIDTH undefined) then
     AVERAGE_WIDTH = ROUND (MEAN (ABS (width of each glyph in font)) * 1
0)
          * (if (dominant writing direction L-to-R) then 1 else -1)

   where MEAN is a function that returns the arithmetic mean of
   its arguments.

   X clients that require values for the number of characters per
   inch (pitch) of a monospaced font can use the following
   algorithm using the AVERAGE_WIDTH and RESOLUTION_X font
   properties:
if (SPACING not proportional) then
   CharPitch = (RESOLUTION_X * 10) / AVERAGE_WIDTH

CHARSET_REGISTRY

   CHARSET_REGISTRY is as defined in the FontName except that the
   property type is ATOM.

   CHARSET_REGISTRY cannot be defaulted if not supplied as a font
   property.

CHARSET_ENCODING

   CHARSET_ENCODING is as defined in the FontName except that the
   property type is ATOM.

   CHARSET_ENCODING cannot be defaulted if not supplied as a font
   property.

MIN_SPACE

   MIN_SPACE is an integer value (of type INT32) that gives the
   recommended minimum word-space value to be used with this font.

   MIN_SPACE can be approximated if not provided as a font
   property, according to the following algorithm:
if (MIN_SPACE undefined) then
   MIN_SPACE = ROUND(0.75 * NORM_SPACE)

NORM_SPACE

   NORM_SPACE is an integer value (of type INT32) that gives the
   recommended normal word-space value to be used with this font.

   NORM_SPACE can be approximated if not provided as a font
   property, according to the following algorithm:
DeciPointsPerInch = 722.7
if (NORM_SPACE undefined) then
   if (SPACE glyph exists) then
      NORM_SPACE = width of SPACE
   else NORM_SPACE = ROUND((0.33 * RESOLUTION_X * POINT_SIZE)/ DeciPoint
sPerInch)

MAX_SPACE

   MAX_SPACE is an integer value (of type INT32) that gives the
   recommended maximum word-space value to be used with this font.

   MAX_SPACE can be approximated if not provided as a font
   property, according to the following algorithm:
if (MAX_SPACE undefined) then
   MAX_SPACE = ROUND(1.5 * NORM_SPACE)

END_SPACE

   END_SPACE is an integer value (of type INT32) that gives the
   recommended spacing at the end of sentences.

   END_SPACE can be approximated if not provided as a font
   property, according to the following algorithm:
if (END_SPACE undefined) then
   END_SPACE = NORM_SPACE

AVG_CAPITAL_WIDTH

   AVG_CAPITAL_WIDTH is an integer value (of type INT32) that
   gives the unweighted arithmetic mean of the absolute value of
   the width of each capital glyph in the font, in tenths of
   pixels, multiplied by -1 if the dominant writing direction for
   the font is right-to-left. This property applies to both Latin
   and non-Latin fonts. For Latin fonts, capitals are the glyphs A
   through Z. This property is usually used for font matching or
   substitution.

   AVG_CAPITAL_WIDTH can be calculated if not provided as a font
   property, according to the following algorithm:
if (AVG_CAPITAL_WIDTH undefined) then
   if (capitals exist) then
      AVG_CAPITAL_WIDTH = ROUND (MEAN
           (ABS (width of each capital glyph)) * 10)
           * (if (dominant writing direction L-to-R) then 1 else -1)
   else AVG_CAPITAL_WIDTH undefined

AVG_LOWERCASE_WIDTH

   AVG_LOWERCASE_WIDTH is an integer value (of type INT32) that
   gives the unweighted arithmetic mean width of the absolute
   value of the width of each lowercase glyph in the font in
   tenths of pixels, multiplied by -1 if the dominant writing
   direction for the font is right-to-left. For Latin fonts,
   lowercase are the glyphs a through z. This property is usually
   used for font matching or substitution.

   Where appropriate, AVG_LOWERCASE_WIDTH can be approximated if
   not provided as a font property, according to the following
   algorithm:
if (AVG_LOWERCASE_WIDTH undefined) then
   if (lowercase exists) then
      AVG_LOWERCASE_WIDTH = ROUND (MEAN
                       (ABS (width of each lowercase glyph)) * 10)
       * (if (dominant writing direction L-to-R) then 1 else -1)
   else AVG_LOWERCASE_WIDTH undefined

QUAD_WIDTH

   QUAD_WIDTH is an integer typographic metric (of type INT32)
   that gives the width of a quad (em) space.

Note

   Because all typographic fixed spaces (em, en, and thin) are
   constant for a given font size (that is, they do not vary
   according to setwidth), the use of this font property has been
   deprecated. X clients that require typographic fixed space
   values are encouraged to discontinue use of QUAD_WIDTH and
   compute these values from other font properties (for example,
   PIXEL_SIZE). X clients that require a font-dependent width
   value should use either the FIGURE_WIDTH or one of the average
   character width font properties (AVERAGE_WIDTH,
   AVG_CAPITAL_WIDTH or AVG_LOWERCASE_WIDTH).

FIGURE_WIDTH

   FIGURE_WIDTH is an integer typographic metric (of type INT32)
   that gives the width of the tabular figures and the dollar
   sign, if suitable for tabular setting (all widths equal). For
   Latin fonts, these tabular figures are the Arabic numerals 0
   through 9.

   FIGURE_WIDTH can be approximated if not supplied as a font
   property, according to the following algorithm:
if (numerals and DOLLAR sign are defined & widths are equal) then
   FIGURE_WIDTH = width of DOLLAR
else FIGURE_WIDTH property undefined

SUPERSCRIPT_X

   SUPERSCRIPT_X is an integer value (of type INT32) that gives
   the recommended horizontal offset in pixels from the position
   point to the X origin of synthetic superscript text. If the
   current position point is at [X,Y], then superscripts should
   begin at [X + SUPERSCRIPT_X, Y - SUPERSCRIPT_Y].

   SUPERSCRIPT_X can be approximated if not provided as a font
   property, according to the following algorithm:
if (SUPERSCRIPT_X undefined) then
   if (TANGENT(ITALIC_ANGLE) defined) then
      SUPERSCRIPT_X = ROUND((0.40 * CAP_HEIGHT) / TANGENT(ITALIC_ANGLE))
   else SUPERSCRIPT_X = ROUND(0.40 * CAP_HEIGHT)

   where TANGENT is a trigonometric function that returns the
   tangent of its argument, which is in 1/64 degrees.

SUPERSCRIPT_Y

   SUPERSCRIPT_Y is an integer value (of type INT32) that gives
   the recommended vertical offset in pixels from the position
   point to the Y origin of synthetic superscript text. If the
   current position point is at [X,Y], then superscripts should
   begin at [X + SUPERSCRIPT_X, Y - SUPERSCRIPT_Y].

   SUPERSCRIPT_Y can be approximated if not provided as a font
   property, according to the following algorithm:
if (SUPERSCRIPT_Y undefined) then
   SUPERSCRIPT_Y = ROUND(0.40 * CAP_HEIGHT)

SUBSCRIPT_X

   SUBSCRIPT_X is an integer value (of type INT32) that gives the
   recommended horizontal offset in pixels from the position point
   to the X origin of synthetic subscript text. If the current
   position point is at [X,Y], then subscripts should begin at [X
   + SUBSCRIPT_X, Y + SUBSCRIPT_Y].

   SUBSCRIPT_X can be approximated if not provided as a font
   property, according to the following algorithm:
if (SUBSCRIPT_X undefined) then
   if (TANGENT(ITALIC_ANGLE) defined) then
      SUBSCRIPT_X = ROUND((0.40 * CAP_HEIGHT) / TANGENT(ITALIC_ANGLE))
   else SUBSCRIPT_X = ROUND(0.40 * CAP_HEIGHT)

SUBSCRIPT_Y

   SUBSCRIPT_Y is an integer value (of type INT32) that gives the
   recommended vertical offset in pixels from the position point
   to the Y origin of synthetic subscript text. If the current
   position point is at [X,Y], then subscripts should begin at [X
   + SUBSCRIPT_X, Y + SUBSCRIPT_Y].

   SUBSCRIPT_Y can be approximated if not provided as a font
   property, according to the following algorithm:
if (SUBSCRIPT_Y undefined) then
   SUBSCRIPT_Y = ROUND(0.40 * CAP_HEIGHT)

SUPERSCRIPT_SIZE

   SUPERSCRIPT_SIZE is an integer value (of type INT32) that gives
   the recommended body size of synthetic superscripts to be used
   with this font, in pixels. This will generally be smaller than
   the size of the current font; that is, superscripts are imaged
   from a smaller font offset according to SUPERSCRIPT_X and
   SUPERSCRIPT_Y.

   SUPERSCRIPT_SIZE can be approximated if not provided as a font
   property, according to the following algorithm:
if (SUPERSCRIPT_SIZE undefined) then
   SUPERSCRIPT_SIZE = ROUND(0.60 * PIXEL_SIZE)

SUBSCRIPT_SIZE

   SUBSCRIPT_SIZE is an integer value (of type INT32) that gives
   the recommended body size of synthetic subscripts to be used
   with this font, in pixels. As with SUPERSCRIPT_SIZE, this will
   generally be smaller than the size of the current font; that
   is, subscripts are imaged from a smaller font offset according
   to SUBSCRIPT_X and SUBSCRIPT_Y.

   SUBSCRIPT_SIZE can be approximated if not provided as a font
   property, according to the algorithm:
if (SUBSCRIPT_SIZE undefined) then
   SUBSCRIPT_SIZE = ROUND(0.60 * PIXEL_SIZE)

SMALL_CAP_SIZE

   SMALL_CAP_SIZE is an integer value (of type INT32) that gives
   the recommended body size of synthetic small capitals to be
   used with this font, in pixels. Small capitals are generally
   imaged from a smaller font of slightly more weight. No offset
   [X,Y] is necessary.

   SMALL_CAP_SIZE can be approximated if not provided as a font
   property, according to the following algorithm:
if (SMALL_CAP_SIZE undefined) then
   SMALL_CAP_SIZE = ROUND(PIXEL_SIZE * ((X_HEIGHT
                              + ((CAP_HEIGHT - X_HEIGHT) / 3)) / CAP_HEI
GHT))

UNDERLINE_POSITION

   UNDERLINE_POSITION is an integer value (of type INT32) that
   gives the recommended vertical offset in pixels from the
   baseline to the top of the underline. If the current position
   point is at [X,Y], the top of the baseline is given by [X, Y +
   UNDERLINE_POSITION].

   UNDERLINE_POSITION can be approximated if not provided as a
   font property, according to the following algorithm:
if (UNDERLINE_POSITION undefined) then
   UNDERLINE_POSITION = ROUND((maximum descent) / 2)

   where maximum descent is the maximum descent (below the
   baseline) in pixels of any glyph in the font.

UNDERLINE_THICKNESS

   UNDERLINE_THICKNESS is an integer value (of type INT32) that
   gives the recommended underline thickness, in pixels.

   UNDERLINE_THICKNESS can be approximated if not provided as a
   font property, according to the following algorithm:
CapStemWidth = average width of the stems of capitals
if (UNDERLINE_THICKNESS undefined) then
   UNDERLINE_THICKNESS = CapStemWidth

STRIKEOUT_ASCENT

   STRIKEOUT_ASCENT is an integer value (of type INT32) that gives
   the vertical ascent for boxing or voiding glyphs in this font.
   If the current position is at [X,Y] and the string extent is
   EXTENT, the upper-left corner of the strikeout box is at [X, Y
   - STRIKEOUT_ASCENT] and the lower-right corner of the box is at
   [X + EXTENT, Y + STRIKEOUT_DESCENT].

   STRIKEOUT_ASCENT can be approximated if not provided as a font
   property, according to the following algorithm:
if (STRIKEOUT_ASCENT undefined)
   STRIKEOUT_ASCENT = maximum ascent

   where maximum ascent is the maximum ascent (above the baseline)
   in pixels of any glyph in the font.

STRIKEOUT_DESCENT

   STRIKEOUT_DESCENT is an integer value (of type INT32) that
   gives the vertical descent for boxing or voiding glyphs in this
   font. If the current position is at [X,Y] and the string extent
   is EXTENT, the upper-left corner of the strikeout box is at [X,
   Y - STRIKEOUT_ASCENT] and the lower-right corner of the box is
   at [X + EXTENT, Y + STRIKEOUT_DESCENT].

   STRIKEOUT_DESCENT can be approximated if not provided as a font
   property, according to the following algorithm:
if (STRIKEOUT_DESCENT undefined)
   STRIKEOUT_DESCENT = maximum descent

   where maximum descent is the maximum descent (below the
   baseline) in pixels of any glyph in the font.

ITALIC_ANGLE

   ITALIC_ANGLE is an integer value (of type INT32) that gives the
   nominal posture angle of the typeface design, in 1/64 degrees,
   measured from the glyph origin counterclockwise from the three
   o'clock position.

   ITALIC_ANGLE can be defaulted if not provided as a font
   property, according to the following algorithm:
if (ITALIC_ANGLE undefined) then
   ITALIC_ANGLE = (90 * 64)

CAP_HEIGHT

   CAP_HEIGHT is an integer value (of type INT32) that gives the
   nominal height of the capital letters contained in the font, as
   specified by the FOUNDRY or typeface designer.

   Certain clients require CAP_HEIGHT to compute scale factors and
   positioning offsets for synthesized glyphs where this
   information or designed glyphs are not explicitly provided by
   the font (for example, small capitals, superiors, inferiors,
   and so on). CAP_HEIGHT is also a critical factor in font
   matching and substitution.

   CAP_HEIGHT can be approximated if not provided as a font
   property, according to the following algorithm:
if (CAP_HEIGHT undefined) then
   if (Latin font) then
      CAP_HEIGHT = XCharStruct.ascent[glyph X]
   else if (capitals exist) then
       CAP_HEIGHT = XCharStruct.ascent[some unaccented capital glyph]
   else CAP_HEIGHT undefined

X_HEIGHT

   X_HEIGHT is an integer value (of type INT32) that gives the
   nominal height above the baseline of the lowercase glyphs
   contained in the font, as specified by the FOUNDRY or typeface
   designer.

   As with CAP_HEIGHT, X_HEIGHT is required by certain clients to
   compute scale factors for synthesized small capitals where this
   information is not explicitly provided by the font resource.
   X_HEIGHT is a critical factor in font matching and
   substitution.

   X_HEIGHT can be approximated if not provided as a font
   property, according to the following algorithm:
if (X_HEIGHT undefined) then
   if (Latin font) then
      X_HEIGHT = XCharStruct.ascent[glyph x]
   else if (lowercase exists) then
        X_HEIGHT = XCharStruct.ascent[some unaccented lc glyph without a
n ascender]
   else X_HEIGHT undefined

RELATIVE_SETWIDTH

   RELATIVE_SETWIDTH is an unsigned integer value (of type CARD32)
   that gives the coded proportionate width of the font, relative
   to all known fonts of the same typeface family, according to
   the type designer's or FOUNDRY's judgment.

   RELATIVE_SETWIDTH ranges from 10 to 90 or is 0 if undefined or
   unknown. The following reference values are defined:
   Code English Translation Description
   0    Undefined           Undefined or unknown
   10   UltraCondensed      The lowest ratio of average width to height
   20   ExtraCondensed
   30   Condensed           Condensed, Narrow, Compressed, ...
   40   SemiCondensed
   50   Medium              Medium, Normal, Regular, ...
   60   SemiExpanded        SemiExpanded, DemiExpanded, ...
   70   Expanded
   80   ExtraExpanded       ExtraExpanded, Wide, ...
   90   UltraExpanded       The highest ratio of average width to height

   RELATIVE_SETWIDTH can be defaulted if not provided as a font
   property, according to the following algorithm:
if (RELATIVE_SETWIDTH undefined) then
   RELATIVE_SETWIDTH = 50

   For polymorphic fonts, RELATIVE_SETWIDTH is not necessarily a
   linear function of the font's setwidth axis.

   X clients that want to obtain a calculated proportionate width
   of the font (that is, a font-independent way of identifying the
   proportionate width across all fonts and all font vendors) can
   use the following algorithm:
SETWIDTH = AVG_CAPITAL_WIDTH / (CAP_HEIGHT * 10)

   where SETWIDTH is a real number with zero being the narrowest
   calculated setwidth.

RELATIVE_WEIGHT

   RELATIVE_WEIGHT is an unsigned integer value (of type CARD32)
   that gives the coded weight of the font, relative to all known
   fonts of the same typeface family, according to the type
   designer's or FOUNDRY's judgment.

   RELATIVE_WEIGHT ranges from 10 to 90 or is 0 if undefined or
   unknown. The following reference values are defined:
   Code English Translation Description
   0 Undefined Undefined or unknown
   10 UltraLight The lowest ratio of stem width to height
   20 ExtraLight
   30 Light
   40 SemiLight SemiLight, Book, ...
   50 Medium Medium, Normal, Regular,...
   60 SemiBold SemiBold, DemiBold, ...
   70 Bold
   80 ExtraBold ExtraBold, Heavy, ...
   90 UltraBold UltraBold, Black, ..., the highest ratio of stem
   width to height

   RELATIVE_WEIGHT can be defaulted if not provided as a font
   property, according to the following algorithm:
if (RELATIVE_WEIGHT undefined) then
   RELATIVE_WEIGHT = 50

   For polymorphic fonts, RELATIVE_WEIGHT is not necessarily a
   linear function of the font's weight axis.

WEIGHT

   Calculated WEIGHT is an unsigned integer value (of type CARD32)
   that gives the calculated weight of the font, computed as the
   ratio of capital stem width to CAP_HEIGHT, in the range 0 to
   1000, where 0 is the lightest weight.

   WEIGHT can be calculated if not supplied as a font property,
   according to the following algorithm:
CapStemWidth = average width of the stems of capitals
if (WEIGHT undefined) then
   WEIGHT = ROUND ((CapStemWidth * 1000) / CAP_HEIGHT)

   A calculated value for weight is necessary when matching fonts
   from different families because both the RELATIVE_WEIGHT and
   the WEIGHT_NAME are assigned by the typeface supplier,
   according to its tradition and practice, and therefore, are
   somewhat subjective. Calculated WEIGHT provides a
   font-independent way of identifying the weight across all fonts
   and all font vendors.

RESOLUTION

   RESOLUTION is an integer value (of type INT32) that gives the
   resolution for which this font was created, measured in 1/100
   pixels per point.

Note

   As independent horizontal and vertical design resolution
   components are required to accommodate displays with nonsquare
   aspect ratios, the use of this font property has been
   deprecated, and independent RESOLUTION_X and RESOLUTION_Y font
   name fields/properties have been defined (see sections 3.1.2.9
   and 3.1.2.10). X clients are encouraged to discontinue use of
   the RESOLUTION property and are encouraged to use the
   appropriate X,Y resolution properties, as required.

FONT

   FONT is a string (of type ATOM) that gives the full XLFD name
   of the font-that is, the value can be used to open another
   instance of the same font.

   If not provided, the FONT property cannot be calculated.

FACE_NAME

   FACE_NAME is a human-understandable string (of type ATOM) that
   gives the full device-independent typeface name, including the
   owner, weight, slant, set, and so on but not the resolution,
   size, and so on. This property may be used as feedback during
   font selection.

   FACE_NAME cannot be calculated or approximated if not provided
   as a font property.

FULL_NAME

   FULL_NAME is the same as FACE_NAME. Its use is deprecated, but
   it is found on some old fonts.

COPYRIGHT

   COPYRIGHT is a human-understandable string (of type ATOM) that
   gives the copyright information of the legal owner of the
   digital font data.

   This information is a required component of a font but is
   independent of the particular format used to represent it (that
   is, it cannot be captured as a comment that could later be
   thrown away for efficiency reasons).

   COPYRIGHT cannot be calculated or approximated if not provided
   as a font property.

NOTICE

   NOTICE is a human-understandable string (of type ATOM) that
   gives the copyright information of the legal owner of the font
   design or, if not applicable, the trademark information for the
   typeface FAMILY_NAME.

   Typeface design and trademark protection laws vary from country
   to country, the USA having no design copyright protection
   currently while various countries in Europe offer both design
   and typeface family name trademark protection. As with
   COPYRIGHT, this information is a required component of a font
   but is independent of the particular format used to represent
   it.

   NOTICE cannot be calculated or approximated if not provided as
   a font property.

DESTINATION

   DESTINATION is an unsigned integer code (of type CARD32) that
   gives the font design destination, that is, whether it was
   designed as a screen proofing font to match printer font glyph
   widths (WYSIWYG), as an optimal video font (possibly with
   corresponding printer font) for extended screen viewing (video
   text), and so on.

   The font design considerations are very different, and at
   current display resolutions, the readability and legibility of
   these two kinds of screen fonts are very different. DESTINATION
   allows publishing clients that use X to model the printed page
   and video text clients, such as on-line documentation browsers,
   to query for X screen fonts that suit their particular
   requirements.

   The encoding is as follows:
   Code English Translation Description
   0 WYSIWYG The font is optimized to match the typographic design
   and metrics of an equivalent printer font.
   1 Video text The font is optimized for screen legibility and
   readability.

FONT_TYPE

   FONT_TYPE is a human-understandable string (of type ATOM) that
   describes the format of the font data as they are read from
   permanent storage by the current font source. It is a static
   attribute of the source data. It can be used by clients to
   select a type of bitmap or outline font without regard to the
   rasterizer used to render the font.

   Predefined values are as follows:
   Value When applicable
   "Bitmap" Hand-tuned bitmap fonts. Some attempt has been made to
   optimize the visual appearance of the font for the requested
   size and resolution.
   "Prebuilt" All bitmap format fonts that cannot be described as
   "Bitmap", that is, handtuned. For example, a bitmap format font
   that was generated mechanically using a scalable font
   rasterizer would be considered "Prebuilt", not "Bitmap".
   "Type 1" Any Type 1 font.
   "TrueType" Any TrueType font.
   "Speedo" Any Speedo font.
   "F3" Any F3 font.

   Other values may be registered with the X Consortium.

FONT_VERSION

   FONT_VERSION is a human-understandable string (of type ATOM)
   that describes the formal or informal version of the font. None
   is a valid value.

RASTERIZER_NAME

   RASTERIZER_NAME is a human-understandable string (of type ATOM)
   that is the specific name of the rasterizer that has performed
   some rasterization operation (such as scaling from outlines) on
   this font.

   To define a RASTERIZER_NAME, the following format is
   recommended:
   RasterizerName ::= OrganizationId Space Rasterizer
   OrganizationId ::= STRING8--the X Registry ORGANIZATION name of
   the rasterizer implementor or maintainer.
   Rasterizer ::= the case-sensitive, human-understandable product
   name of the rasterizer. Words within this name should be
   separated by a single SPACE.
   Space ::= OCTET-" " (SPACE)

   Examples:
      X Consortium Bit Scaler
      X Consortium Type 1 Rasterizer
      X Consortium Speedo Rasterizer
      Adobe Type Manager
      Sun TypeScaler

   If RASTERIZER_NAME is not defined, or is None, no rasterization
   operation has been applied to the FONT_TYPE.

RASTERIZER_VERSION

   RASTERIZER_VERSION is a human-understandable string (of type
   ATOM) that represents the formal or informal version of a font
   rasterizer. The RASTERIZER_VERSION should match the
   corresponding product version number known to users, when
   applicable.

RAW_ASCENT

   For a font with a transformation matrix, RAW_ASCENT is the font
   ascent in 1000 pixel metrics (see Metrics and Font Properties).

RAW_DESCENT

   For a font with a transformation matrix, RAW_DESCENT is the
   font descent in 1000 pixel metrics (see Metrics and Font
   Properties).

RAW_*

   For a font with a transformation matrix, all font properties
   that represent horizontal or vertical sizes or displacements
   will be accompanied by a new property, named as the original
   except prefixed with "RAW_", that is computed as described in
   Metrics and Font Properties.

AXIS_NAMES

   AXIS_NAMES is a list of all the names of the axes for a
   polymorphic font, separated by a null (0) byte. These names are
   suitable for presentation in a user interface (see section 6).

AXIS_LIMITS

   AXIS_LIMITS is a list of integers, two for each axis, giving
   the minimum and maximum allowable values for that axis of a
   polymorphic font (see Polymorphic Fonts).

AXIS_TYPES

   AXIS_TYPES is like AXIS_NAMES, but can be registered as having
   specific semantics (see section 6).

Built-in Font Property Atoms

   The following font property atom definitions were predefined in
   the initial version of the core protocol:
   Font Property/Atom Name Property Type
   MIN_SPACE               INT32
   NORM_SPACE              INT32
   MAX_SPACE               INT32
   END_SPACE               INT32
   SUPERSCRIPT_X           INT32
   SUPERSCRIPT_Y           INT32
   SUBSCRIPT_X             INT32
   SUBSCRIPT_Y             INT32
   UNDERLINE_POSITION      INT32
   UNDERLINE_THICKNESS     INT32
   STRIKEOUT_ASCENT        INT32
   STRIKEOUT_DESCENT       INT32
   FONT_ASCENT             INT32
   FONT_DESCENT            INT32
   ITALIC_ANGLE            INT32
   X_HEIGHT                INT32
   QUAD_WIDTH              INT32 -^deprecated
   WEIGHT                  CARD32
   POINT_SIZE              INT32
   RESOLUTION              CARD32 -^deprecated
   COPYRIGHT               ATOM
   FULL_NAME               ATOM -^deprecated
   FAMILY_NAME             ATOM
   DEFAULT_CHAR            CARD32

Chapter 4. Matrix Transformations

   Table of Contents

   Metrics and Font Properties

   An XLFD name presented to the server can have the POINT_SIZE or
   PIXEL_SIZE field begin with the character "[". If the first
   character of the field is "[", the character must be followed
   with ASCII representations of four floating point numbers and a
   trailing "]", with white space separating the numbers and
   optional white space separating the numbers from the "[" and
   "]" characters. Numbers use standard floating point syntax but
   use the character "~" to represent a minus sign in the mantissa
   or exponent.

   The BNF for a matrix transformation string is as follows:
   MatrixString ::= LeftBracket OptionalSpace Float Space Float
   Space Float Space Float OptionalSpace RightBracket
   OptionalSpace ::= "" | Space
   Space ::= SpaceChar | SpaceChar Space
   Float ::= Mantissa | Mantissa Exponent
   Mantissa ::= Sign Number | Number
   Sign ::= Plus | Tilde
   Number ::= Integer | Integer Dot Integer | Dot Integer
   Integer ::= Digit | Digit Integer
   Digit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" |
   "9"
   Exponent ::= "e" SignedInteger | "E" SignedInteger
   SignedInteger ::= Sign Integer | Integer
   LeftBracket ::= OCTET - "[" (LEFT SQUARE BRACKET)
   RightBracket ::= OCTET - "]" (RIGHT SQUARE BRACKET)
   SpaceChar ::= OCTET - " " (SPACE)
   Tilde ::= OCTET - "~" (TILDE)
   Plus ::= OCTET - "+" (PLUS)
   Dot ::= OCTET - "." (FULL STOP)

   The string "[a b c d]" represents a graphical transformation of
   the glyphs in the font by the matrix
   [ a b 0 ]
   [ c d 0 ]
   [ 0 0 1 ]

   All transformations occur around the origin of the glyph. The
   relationship between the current scalar values and the matrix
   transformation values is that the scalar value "N" in the
   POINT_SIZE field produces the same glyphs as the matrix "[N/10
   0 0 N/10]" in that field, and the scalar value "N" in the
   PIXEL_SIZE field produces the same glyphs as the matrix
   "[N*RESOLUTION_X/RESOLUTION_Y 0 0 N]" in that field.

   If matrices are specified for both the POINT_SIZE and
   PIXEL_SIZE, they must bear the following relationship to each
   other within an implementation-specific tolerance:

     PIXEL_SIZE_MATRIX = [Sx 0 0 Sy] * POINT_SIZE_MATRIX

   where

     Sx = RESOLUTION_X / 72.27

     Sy = RESOLUTION_Y / 72.27

   If either the POINT_SIZE or PIXEL_SIZE field is unspecified
   (either "0" or wildcarded), the preceding formulas can be used
   to compute one from the other.

Metrics and Font Properties

   In this section, the phrase "1000 pixel metrics" means the
   metrics that would be obtained if the rasterizer took the base
   untransformed design used to generate the transformed font and
   scaled it linearly to a height of 1000 pixels, with no rotation
   component. Note that there may be no way for the application to
   actually request this font since the rasterizer may use
   different outlines or rasterization techniques at that size
   from the ones used to generate the transformed font.

   Notes on properties and metrics:

   The per-char ink metrics (lbearing, rbearing, ascent, and
   descent) represent the ink extent of the transformed glyph
   around its origin.

   The per-char width is the x component of the transformed
   character width.

   The font ascent and descent are the y component of the
   transformed font ascent or descent.

   The FONT property returns a name reflecting the matrix being
   used-that is, the name returned can be used to open another
   instance of the same font. The returned name is not necessarily
   an exact copy of the requested name. If, for example, the user
   requests
   -misc-fixed-medium-r-normal--0-[2e1 0 0.0 +10.0]-72-72-c-0-iso8859-1

   the resulting FONT property might be
   -misc-fixed-medium-r-normal--[19.9 0 0 10]-[20 0 0 10]-72-72-c-0-iso8
859-1

   The FONT property will always include matrices in both the
   PIXEL_SIZE and the POINT_SIZE fields.

   To allow accurate client positioning of transformed characters,
   the attributes field of the XCharInfo contains the width of the
   character in 1000 pixel metrics. This attributes field should
   be interpreted as a signed integer.

   There will always be 2 new font properties defined, RAW_ASCENT
   and RAW_DESCENT, that hold the ascent and descent in 1000 pixel
   metrics.

   All font properties that represent horizontal widths or
   displacements have as their value the x component of the
   transformed width or displacement. All font properties that
   represent vertical heights or displacements have as their value
   the y component of the transformed height or displacement. Each
   such property will be accompanied by a new property, named as
   the original except prefixed with "RAW_", that gives the value
   of the width, height, or displacement in 1000 pixel metrics.

Chapter 5. Scalable Fonts

   The XLFD is designed to support scalable fonts. A scalable font
   is a font source from which instances of arbitrary size can be
   derived. A scalable font source might be one or more outlines
   together with zero or more hand-tuned bitmap fonts at specific
   sizes and resolutions, or it might be a programmatic
   description together with zero or more bitmap fonts, or some
   other format (perhaps even just a single bitmap font).

   The following definitions are useful for discussing scalable
   fonts:

   Well-formed XLFD pattern
     * Well-formed XLFD pattern
       A pattern string containing 14 hyphens, one of which is the
       first character of the pattern. Wildcard characters are
       permitted in the fields of a well-formed XLFD pattern.

     * Scalable font name
       A well-formed XLFD pattern containing no wildcards and
       containing the digit "0" in the PIXEL_SIZE, POINT_SIZE, and
       AVERAGE_WIDTH fields.

     * Scalable fields
       The XLFD fields PIXEL_SIZE, POINT_SIZE, RESOLUTION_X,
       RESOLUTION_Y, and AVERAGE_WIDTH.

     * Derived instance
       The result of replacing the scalable fields of a font name
       with values to yield a font name that could actually be
       produced from the font source. A scaling engine is
       permitted, but not required, to interpret the scalable
       fields in font names to support anamorphic scaling.

     * Global list
       The list of names that would be returned by an X server for
       a ListFonts protocol request on the pattern "*" if there
       were no protocol restrictions on the total number of names
       returned.

   The global list consists of font names derived from font
   sources. If a single font source can support multiple character
   sets (specified in the CHARSET_REGISTRY and CHARSET_ENCODING
   fields), each such character set should be used to form a
   separate font name in the list. For a nonscalable font source,
   the simple font name for each character set is included in the
   global list. For a scalable font source, a scalable font name
   for each character set is included in the list. In addition to
   the scalable font name, specific derived instance names may
   also be included in the list. The relative order of derived
   instances with respect to the scalable font name is not
   constrained. Finally, font name aliases may also be included in
   the list. The relative order of aliases with respect to the
   real font name is not constrained.

   The values of the RESOLUTION_X and RESOLUTION_Y fields of a
   scalable font name are implementation dependent, but to
   maximize backward compatibility, they should be reasonable
   nonzero values, for example, a resolution close to that
   provided by the screen (in a single-screen server). Because
   some existing applications rely on seeing a collection of point
   and pixel sizes, server vendors are strongly encouraged in the
   near term to provide a mechanism for including, for each
   scalable font name, a set of specific derived instance names.
   For font sources that contain a collection of hand-tuned bitmap
   fonts, including names of these instances in the global list is
   recommended and sufficient.

   The X protocol request OpenFont on a scalable font name returns
   a font corresponding to an implementation-dependent derived
   instance of that font name.

   The X protocol request ListFonts on a well-formed XLFD pattern
   returns the following. Starting with the global list, if the
   actual pattern argument has values containing no wildcards in
   scalable fields, then substitute each such field into the
   corresponding field in each scalable font name in the list. For
   each resulting font name, if the remaining scalable fields
   cannot be replaced with values to produce a derived instance,
   remove the font name from the list. Now take the modified list,
   and perform a simple pattern match against the pattern
   argument. ListFonts returns the resulting list.

   For example, given the global list:
-Linotype-Times-Bold-I-Normal--0-0-100-100-P-0-ISO8859-1
-Linotype-Times-Bold-R-Normal--0-0-100-100-P-0-ISO8859-1
-Linotype-Times-Medium-I-Normal--0-0-100-100-P-0-ISO8859-1
-Linotype-Times-Medium-R-Normal--0-0-100-100-P-0-ISO8859-1

   a ListFonts request with the pattern:
-*-Times-*-R-Normal--*-120-100-100-P-*-ISO8859-1

   would return:
-Linotype-Times-Bold-R-Normal--0-120-100-100-P-0-ISO8859-1
-Linotype-Times-Medium-R-Normal--0-120-100-100-P-0-ISO8859-1

   ListFonts on a pattern containing wildcards that is not a
   well-formed XLFD pattern is only required to return the list
   obtained by performing a simple pattern match against the
   global list. X servers are permitted, but not required, to use
   a more sophisticated matching algorithm.

Chapter 6. Polymorphic Fonts

   Fonts that can be varied in ways other than size or resolution
   are called polymorphic fonts. Multiple Master Type 1 font
   programs are one type of a polymorphic font. Current examples
   of axes along which the fonts can be varied are width, weight,
   and optical size; others might include formality or x-height.

   To support polymorphic fonts, special values indicating
   variability are defined for the following XLFD fields:

     WEIGHT_NAME

     SLANT

     SETWIDTH_NAME

     ADD_STYLE_NAME

   The string "0" is the special polymorphic value. In the
   WEIGHT_NAME, SLANT, or SETWIDTH_NAME field, "0" must be the
   entire field. There may be multiple polymorphic values in the
   ADD_STYLE_NAME field. They are surrounded by "[" and "]" and
   separated by a Space, as "[0\00]". The polymorphic values may
   coexist with other data in the field. It is recommended that
   the polymorphic values be at the end of the ADD_STYLE_NAME
   field.

   The font-matching algorithms for a font with polymorphic fields
   are identical to the matching algorithms for a font with
   scalable fields.

   There are three new font properties to describe the axes of
   variation, AXIS_NAMES, AXIS_LIMITS, and AXIS_TYPES. AXIS_NAMES
   is a list of all the names of the axes for the font, separated
   by a null (0) byte. These names are suitable for presentation
   in a user interface. AXIS_LIMITS is a list of integers, two for
   each axis, giving the minimum and maximum allowable values for
   that axis. AXIS_TYPES is like AXIS_NAMES, but can be registered
   as having specific semantics.

   The axes are listed in the properties in the same order as they
   appear in the font name. They are matched with font name fields
   by looking for the special polymorphic values in the font name.

   Examples:

   The Adobe Myriad MM font program has width and weight axes.
   Weight can vary from 215 to 830, and width from 300 to 700.
Name:
        -Adobe-Myriad MM-0-R-0--0-0-0-0-P-0-ISO8859-1
AXIS_NAMES:
        Weight, Width
AXIS_LIMITS:
        215, 830, 300, 700
AXIS_TYPES:
        Adobe-Weight, Adobe-Width
Sample derived instance:
        -Adobe-Myriad MM-412-R-575--*-120-100-100-P-*-ISO8859-1

   The Adobe Minion MM Italic font program has width, weight, and
   optical size axes.
Name:
         -Adobe-Minion MM-0-I-0-[0]-0-0-0-0-P-0-ISO8859-1
AXIS_NAMES:
         Weight, Width, Optical size
AXIS_LIMITS:
         345, 620, 450, 600, 6, 72
AXIS_TYPES:
         Adobe-Weight, Adobe-Width, Adobe-OpticalSize
Sample derived instance:
         -Adobe-Minion MM-550-I-480-[18]-*-180-100-100-P-*-ISO8859-1

   The Adobe Minion MM Swash Italic font program has the same axes
   and values. This shows how "[0]" in the ADD_STYLE_NAME field
   can coexist with other words.
Name:
        -Adobe-Minion MM-0-I-0-Swash[0]-0-0-0-0-P-0-ISO8859-1
AXIS_NAMES:
        Weight, Width, Optical size
AXIS_LIMITS:
        345, 620, 450, 600, 6, 72
AXIS_TYPES:
        Adobe-Weight, Adobe-Width, Adobe-OpticalSize
Sample derived instance:
        -Adobe-Minion MM-550-I-480-Swash[18]-*-180-100-100-P-*-ISO8859-1

   The XYZ Abc font, a hypothetical font, has optical size and
   x-height axes. This shows how there can be more than one
   polymorphic value in the ADD_STYLE_NAME field.
Name:
        -XYZ-Abc-Medium-R-Normal-[0 0]-0-0-0-0-P-0-ISO8859-1
AXIS_NAMES:
        Optical size, X-height
AXIS_LIMITS:
        6, 72, 400, 600
AXIS_TYPES:
        XYZ-OpticalSize, XYZ-Xheight
Sample derived instance:
        -XYZ-Abc-Medium-R-Normal-[14 510]-*-140-100-100-P-*-ISO8859-1

   If an axis allows negative values, a client requests a negative
   value by using "~" (TILDE) as a minus sign.

   Axis types can be registered with the X Consortium, along with
   their semantics.

   If a font name that contains the polymorphic value or a
   wildcard in a polymorphic field is presented to a font source,
   the font source is free to substitute any value that is
   convenient. However, font sources should try to use a value
   that would be considered normal or medium for the particular
   font. For example, if an optical size variable is unresolved,
   the font source should provide a value appropriate to the size
   of the font.

   The result of specifying an out-of-range value for a
   polymorphic field is undefined. The font source may treat this
   as a BadName error, treat the value as if it were the closest
   legal value, or extrapolate to try to accommodate the value.

Chapter 7. Affected Elements of Xlib and the X Protocol

   The following X protocol requests must support the XLFD
   conventions:
     * OpenFont - for the name argument
     * ListFonts - for the pattern argument
     * ListFontsWithInfo - for the pattern argument

   In addition, the following Xlib functions must support the XLFD
   conventions:
     * XLoadFont - for the name argument
     * XListFontsWithInfo - for the pattern argument
     * XLoadQueryFont - for the name argument
     * XListFonts - for the pattern argument

Chapter 8. BDF Conformance

   Table of Contents

   XLFD Conformance Requirements
   FONT_ASCENT, FONT_DESCENT, and DEFAULT_CHAR

        FONT_ASCENT
        FONT_DESCENT
        DEFAULT_CHAR

   The bitmap font distribution and interchange format adopted by
   the X Consortium (BDF V2.1) provides a general mechanism for
   identifying the font name of an X font and a variable list of
   font properties, but it does not mandate the syntax or
   semantics of the font name or the semantics of the font
   properties that might be provided in a BDF font. This section
   identifies the requirements for BDF fonts that conform to XLFD.

XLFD Conformance Requirements

   A BDF font conforms to the XLFD specification if and only if
   the following conditions are satisfied:
     * The value for the BDF item FONT conforms to the syntax and
       semantic definition of a XLFD FontName string.
     * The FontName begins with the X FontNameRegistry prefix:
       "-".
     * All XLFD FontName fields are defined.
     * Any FontProperties provided conform in name and semantics
       to the XLFD FontProperty definitions.

   A simple method of testing for conformance would entail
   verifying that the FontNameRegistry prefix is the string "-",
   that the number of field delimiters in the string and coded
   field values are valid, and that each font property name either
   matches a standard XLFD property name or follows the definition
   of a private property.

FONT_ASCENT, FONT_DESCENT, and DEFAULT_CHAR

   FONT_ASCENT, FONT_DESCENT, and DEFAULT_CHAR are provided in the
   BDF specification as properties that are moved to the
   XFontStruct by the BDF font compiler in generating the X
   server-specific binary font encoding. If present, these
   properties shall comply with the following semantic
   definitions.

FONT_ASCENT

   FONT_ASCENT is an integer value (of type INT32) that gives the
   recommended typographic ascent above the baseline for
   determining interline spacing. Specific glyphs of the font may
   extend beyond this. If the current position point for line n is
   at [X,Y], then the origin of the next line m = n + 1 (allowing
   for a possible font change) is [X, Y + FONT_DESCENTn +
   FONT_ASCENTm].

   FONT_ASCENT can be approximated if not provided as a font
   property, according to the following algorithm:
if (FONT_ASCENT undefined) then
   FONT_ASCENT = maximum ascent

   where maximum ascent is the maximum ascent (above the baseline)
   in pixels of any glyph in the font.

FONT_DESCENT

   FONT_DESCENT is an integer value (of type INT32) that gives the
   recommended typographic descent below the baseline for
   determining interline spacing. Specific glyphs of the font may
   extend beyond this. If the current position point for line n is
   at [X,Y], then the origin of the next line m = n+1 (allowing
   for a possible font change) is [X, Y + FONT_DESCENTn +
   FONT_ASCENTm].

   The logical extent of the font is inclusive between the
   Y-coordinate values: Y - FONT_ASCENT and Y + FONT_DESCENT + 1.

   FONT_DESCENT can be approximated if not provided as a font
   property, according to the following algorithm:
if (FONT_DESCENT undefined) then
   FONT_DESCENT = maximum descent

   where maximum descent is the maximum descent (below the
   baseline) in pixels of any glyph in the font.

DEFAULT_CHAR

   The DEFAULT_CHAR is an unsigned integer value (of type CARD32)
   that specifies the index of the default character to be used by
   the X server when an attempt is made to display an undefined or
   nonexistent character in the font. (For a font using a 2-byte
   matrix format, the index bytes are encoded in the integer as
   byte1 * 65536 + byte2.) If the DEFAULT_CHAR itself specifies an
   undefined or nonexistent character in the font, then no display
   is performed.

   DEFAULT_CHAR cannot be approximated if not provided as a font
   property.
