Explicit Font Selection

An application can select either a public or a private font with GpiCreateLogFont. A public font is available to all applications. A private font is loaded by an application for its exclusive use.

Use the Presentation Manager Control Panel to load a public font. Four DLLs contain the Times Roman, Helvetica, Courier, and System Monospaced image fonts. The names of these libraries are:

• TIMES.FON
  
• HELV.FON
  
• COURIER.FON
  
• SYSMONO.FON

Unlike most DLLs, font libraries typically use the file name extension .FON. If the user loads all four libraries, a total of 76 public fonts are available. An application can use both outline and image formats of these fonts. Characters in the image format are available in sizes ranging from 8 to 24 points. Characters in the outline format can be any size.

Call GpiLoadFonts to load a private font. Pass the function the path and name of the DLL that contains the font. After the application loads the DLL of fonts, it can determine the characteristics of the fonts in that library by calling GpiQueryFonts.

To select a public font from all of the available public fonts, do the following:

• Call GpiQueryFonts. passing the QF_PUBLIC flag, a NULL pointer to the font's face name, and a count of 0 to determine the number of available public fonts, as shown in the following figure.

  #define INCL_GPILCIDS#include <os2.h>
  void fncFONT06(void){
  
      FONTMETRICS fm, afm[80];
      LONG cFonts = 0, cPublicFonts;
      HPS hps;
  
      cPublicFonts = GpiQueryFonts(hps,      /* Queries all public fonts */
      QF_PUBLIC,
      (PSZ) NULL,
      &cFonts,
      sizeof(fm),
      (PFONTMETRICS) NULL);
  } /* fncFONT06 */
  

  Note: To load and use a private font, follow the same procedure, but specify QF_PRIVATE, instead of QF_PUBLIC, in the calls to GpiQueryFonts.

• Copy the value returned by GpiQueryFonts into a LONG integer variable.

• Allocate memory for the FONTMETRICS data structures.

• Call GpiQueryFonts again, passing the QF_PUBLIC flag, a NULL pointer to the font's face name, the count returned by the previous call, and the address of an array of FONTMETRICS structures.

  GpiQueryFonts the font metrics of every font available the array of FONTMETRICS structures. The font metrics define in detail the physical characteristics of a font.

  Because the font metrics are so detailed, the amount of information returned to you from GpiQueryFonts can be extensive. You can restrict the amount of information returned by this function by:

  • Specifying an absolute number of fonts about which you require information.
    
  • Asking for information about fonts of a specific face name only.
    
  • Limiting the length of the font-metrics buffer.
  If you request information for more fonts than are available on the system, GpiQueryFonts returns all the information about the available fonts and a value indicating how many fonts it has returned.

  If you request information for fewer fonts than are available on the system (that match the specified face name, and so forth), GpiQueryFonts returns a value indicating the number of fonts that it was unable to return.

  The following figure is an example of this technique of selecting a font.

  #define INCL_GPILCIDS
  #include <os2.h>
  
  PFONTMETRICS fncFONT07 (HPS hps, PLONG pcPublicFonts) {
     PFONTMETRICS afm = NULL;
     LONG         fonts = 1000;
  
     *pcPublicFonts = GpiQueryFonts(hps,
                                    QF_PUBLIC,
                                    (PSZ) NULL,
                                    &fonts,
                                    sizeof(*afm),
                                    (PFONTMETRICS) NULL);
  
     if (!DosAllocMem(&afm,
                      sizeof(*afm)*(*pcPublicFonts),
                      PAG_COMMIT | PAGWRITE )) {
         GpiQueryFonts(hps,
                      QF_PUBLIC,
                      (PSZ) NULL,
                      pcPublicFonts,
                      sizeof(*afm),
                      afm);
     } /* endif */
     return afm;
  }
  

Examine the array of FONTMETRICS structures.

a.

For an outline font, examine the face name and other attributes of the font your application requires.
b.
For an image font, examine the device resolution fields. These fields are the ones that determine if a particular font and its metrics match the device with which you wish to use it.
Note: If your application is interactive, organize the face names and other information relevant to those fonts (such as point sizes) in a menu. When the operator has selected a font, supply the relevant information from the font metrics of that font in the FATTRS structure of GpiCreateLogFont.
6.
After determining which font to use, your application must fill in the fields of the FATTRS structure. Some of the data for these fields will be copied (explicitly) from the FONTMETRICS structure. Then call GpiCreateLogFont.

If you do not supply a face name, the default font is used. If you supply a face name, and the presentation driver cannot find a matching font, a default font is selected.

The FATTRS structure describes a logical font. An application can have up to 254 logical fonts defined at any one time in a single presentation space. A logical font is a list of font attributes, whereas a physical font is the bit-map or vector information that the system uses to draw characters.

7.
The fonts supplied by the PM programming interface, the fonts you load using the Control Panel, and any fonts you load with GpiLoadFonts are all physical fonts.

Copying the entries in the FATTRS structure ensures that, if a particular font is unavailable, an attempt is made to find the most suitable substitute. Without the FATTRS information, PM is less likely to locate a suitable font.

8.
Initialize a local identifier (lcid) for the new font.
9.
Call GpiCreateLogFont and pass as input parameters:

• The lcid for the font

• The address of an 8-character array containing the name you want to give to the logical font, (or, if you do not want to specify a name, the value NULL)

• The address of the FATTRS structure
10.
Examine the return value from GpiCreateLogFont. The value will be 2 if the function is successful; 1, if the default font was used.
11.
Pass the lcid to GpiSetCharSet, assigning the font to your application's presentation space. Then the application can use it for text output. (This step identifies a logical font as the current font.)

The following figure shows how to select an image font at least 14 device coordinate units high.

#define INCL_GPILCIDS#include <os2.h>

LONG fncFONT08(HPS hps, LONG lcid, LONG xres, LONG yres) {
   FATTRS       fat;
   PFONTMETRICS afm;
   LONG         cFonts;
   LONG         i;
   LONG         rc = 0;

   afm = fncFONT07(hps, &cfonts);
   if (amf) {
      for (i=0; 1<cfonts; i++) {
         if (!(afm[i].fsDefn & FM_DEFN_OUTLINE)
            afm[i].sXDeviceRes == xres &&
            afm[i].sYDeviceRes == yres &&
            afm[i].lMaxBaselineExt >= 14)  {
           fat.usRecordLength = sizeof(fat);
           fat.fsSelection = 0;
           fat.lMatch = 0;
           strcpy(fat.szFacename, afm[i].szFacename);
           fat.idRegistry = afm[i].idRegistry;
           fat.usCodePage = 0;
           fat.lMaxBaselineExt = afm[i].lMaxBaselineExt;
           fat.lAveCharWidth = afm[i].lAveCharWidth;
           fat.fsType = 0;
           fat.fsFontUse = 0;

           rc = GpiCreateLogFont(hps, (PSTR8) NULL, lcid, &fat);
           if (rc) {
              GpiSetCharSet(hps, lcid);
           } /* endif */
        } /* endfor */

     } /* endif */

     return rc;
}

GpiQueryFonts returns device coordinates for image fonts. For outline fonts, it returns notional coordinates. Notional coordinates are the coordinate in which the font was defined. Usually outline fonts are defined over a 1000-by-1000 matrix, with the unit of the matrix a 1/1000 of the em height.

---

[Back: Selecting a Font]
[Next: Reassociating the Presentation Space]