X Logical Font Description Conventions

The FontName is a structured, parsable string (of type STRING8) whose Backus-Naur Form syntax description is as follows:

Field values are constructed as strings of ISO 8859-1 graphic characters, excluding the following:

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.

This section discusses the FontName:

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

The following examples of font names are derived from the screen fonts shipped with the X Consortium distribution.

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 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 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 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 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 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 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 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 is as defined in the FontName except that the property type is CARD32.

RESOLUTION_X cannot be calculated or approximated.

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

RESOLUTION_X cannot be calculated or approximated.

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 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)) * 10)
          * (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 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 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 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 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)/ DeciPointsPerInch)

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 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 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 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 is an integer typographic metric (of type INT32) that gives the width of a quad (em) space.

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 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 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 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 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 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 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 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_HEIGHT))

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 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 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 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 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 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 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 an ascender]
   else X_HEIGHT undefined

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:

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 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:

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.

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 is an integer value (of type INT32) that gives the resolution for which this font was created, measured in 1/100 pixels per point.

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 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 is the same as FACE_NAME. Its use is deprecated, but it is found on some old fonts.

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 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 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:

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:

Other values may be registered with the X Consortium.

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 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:

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 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.

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

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

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 the section called “Metrics and Font Properties”.

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 is a list of integers, two for each axis, giving the minimum and maximum allowable values for that axis of a polymorphic font (see Chapter 6, Polymorphic Fonts).

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

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 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.

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.