Aros/Developer/Docs/Libraries/DiskFont

Fonts
AROS can use two different fonts and Other font types such as the more common TrueType (AROS uses FreeType equivalent) fonts, you need to use another library

A font is basically a mixture of the typeface (shape of letters), style (bold, plain, italic) and size (measured in fonts). The AROS has one built in font called Topaz which can be accessed at all times. If using a disk based font, then you need to use the diskfont.library to load a font from disk.

Bitmap Fonts
bitplane data in a custom format along with some metadata for the horizontal offset and left/right side widths of each character. The loader is in Diskfont.library as OpenDiskFont. Once loaded, a bitmap font is processed by OpenFont

Wanderer calls IconList with NULL font, because diskfont.library is not able to open "arial.font". This happens on the other hand because diskfont.library is not finding the arial.font in FONTS:, because ExAll call returns 0 (== done) on its first call. This means not all fonts are returned, because the passed 1024 bytes buffer is too small to get them all in one go.

Loading a disk font

To load a diskfont, use the OpenDiskFont function. You need to specify a TextAttr structure to state which font you require, the format of the command is:

TextFont font = OpenDiskFont(struct TextAttr textAttr)

The format of the TextAttr is: struct TextAttr { STRPTR ta_Name; /* name of the font */ UWORD ta_YSize; /* height of the font */ UBYTE ta_Style; /* intrinsic font style */ UBYTE ta_Flags; /* font preferences and flags */ };

For example, to specify a Topaz font, size 11 with Bold and Italic:

struct TextAttr myta = { "topaz.font" 11,  FSF_ITALIC | FSF_BOLD, NULL };

If you are drawing with this font, you can change the default Rastport font with the SetFont command and when done with it using the CloseFont functions: e.g. struct TextFont *myfont, *oldfont; struct RastPort *myrp; struct Window *mywin;

if (myfont = OpenDiskFont(&myta)) { /* you would probably set the font of the rastport you are going to use */ myrp = mywin->RPort oldfont = myrp->Font; SetFont(myrp, myfont);

/* perform whatever drawing you need to do */

/* time to clean up. If the rastport is not exclusively yours, you may need to restore the original font or other Rasport values */ SetFont(myrp, oldfont); CloseFont(myfont); }

If you want to know what fonts are available in your program before trying to load one from disk, then you can use the AvailFonts function which can read all the fonts from memory and disk and present them in an AvailFontsHeader structure, followed by a number of AvailFonts structures to be read by your program. You need to allocate some memory before calling this function to store the font information.

LONG error = AvailFonts(struct AvailFontsHeader *buffer, LONG bufBytes, ULONG flags )

For example,

int afShortage, afSize; struct AvailFontsHeader *afh;

afSize = 400; do { afh = (struct AvailFontsHeader *) AllocMem(afSize, 0); if (afh) { afShortage = AvailFonts(afh, afSize, AFF_MEMORY|AFF_DISK); if (afShortage) { FreeMem(afh, afSize); afSize += afShortage; } }  else { fail("AllocMem of AvailFonts buffer afh failedn"); break; } }while (afShortage);

For each font size described in a FontContents (or TFontContents) structure, there is a corresponding file in that font's directory whose name is its size. For example, for the font size Sapphire-19, there is a file in the Sapphire directory called 19. That file is basically a DiskFontHeader disguised as a loadable DOS hunk and is known as a font descriptor file.

For a bitmap font, the ".font" file is a FontContentsHeader structure:

struct FontContentsHeader { UWORD  fch_FileID;             /* FCH_ID */ UWORD  fch_NumEntries;         /* the number of FontContents elements */ struct FontContents fch_FC[];  /* or struct TFontContents fch_TFC[];  */ };


 * 1) define MAXFONTPATH 256

Where the fch_FileID field can be either:

FCH_ID   0x0f00    uses FontContents structures to describe the available sizes of this font.

TFCH_ID  0x0f02    uses TFontContents structures to describe the available sizes of this font.

The FontContents structure: struct FontContents { char   fc_FileName[MAXFONTPATH]; UWORD  fc_YSize; UBYTE  fc_Style; UBYTE  fc_Flags; };

struct TFontContents { char   tfc_FileName[MAXFONTPATH-2]; UWORD  tfc_TagCount;       /* including the TAG_DONE tag */ /*        *  if tfc_TagCount is non-zero, tfc_FileName is overlaid with * Text Tags starting at:  (struct TagItem *) *     &tfc_FileName[MAXFONTPATH-(tfc_TagCount*sizeof         *                                 (struct TagItem))] */   UWORD   tfc_YSize; UBYTE  tfc_Style; UBYTE  tfc_Flags; };

struct DiskFontHeader { ULONG    dfh_NextSegment; ULONG    dfh_ReturnCode; STRUCT   dfh,LN_SIZE; UWORD    dfh_FileID; UWORD    dfh_Revision; LONG     dfh_Segment; STRUCT   dfh,MAXFONTNAME; STRUCT   dfh-TF,tf_SIZEOF; };

Does anyone know what program was used to generate the ttcourier fonts? They were committed by Georg in 2001.

IIRC BitLine (see Aminet, comes with source code). Loads font into memory using diskfont.library and then saves it to disk. Source font was truetype font which diskfont.library transforms into bitmap font during loading (if there's a font engine like the freetype based ones which can handle it).

There's a small problem with these fonts: the glyphs are all aligned to the left of their box rather than to the centre (this is one of the papercut bugs).

A quick look at the ttcourier font (with tools like sys:tools/fontinfo and the bitmap font editor "TypeFace" in sys:extras/misc/aminet/). It seems only some sizes (like 14) have the problem and problem is missing/zero kerning/spacing tables.

Also looking at the svn log of the font files ("14", etc.) in workbench/fonts/ it seems problem may have happened when the Euro character was (manually) added to the fonts (IIRC with Typeface font editor running under AROS -> maybe a bug there), as I did a quick test with the initial revision of the "14" file which did not seem to have the kerning/spacing tables missing.

FreeType Outline Fonts
Note that depending on style and other things fonts are not not always rendered with the same HIDD method. See rom/graphics/text.c. The text not visible on the screenshot is those which gets rendered with BlitColorexpansion method.

Examples

 * 1) include 
 * 2) include 
 * 3) include 
 * 4) include 
 * 5) include 
 * 6) include 


 * 1) include 
 * 2) include 
 * 3) include 

struct Library *DiskfontBase; struct UtilityBase *UtilityBase;

UBYTE *buf;

void cleanup(char *msg) {   if (msg) printf("aftest: %s\n", msg); if (buf) FreeVec(buf); if (UtilityBase) CloseLibrary((struct Library *)UtilityBase); if (DiskfontBase) CloseLibrary(DiskfontBase); exit(0); }

void openlibs(void) {   DiskfontBase = OpenLibrary("diskfont.library", 0); if (!DiskfontBase) cleanup("Cant open diskfont.library!"); UtilityBase = (struct UtilityBase *) OpenLibrary("utility.library", 0); if (!UtilityBase) cleanup("Cant open utility.library!"); }

void action(void) {   struct TextFont *font; struct TextAttr ta;

ta.ta_Name = "Vera Sans Bold Italic.font"; ta.ta_Name = "xhelvetica.font"; ta.ta_YSize = 11; ta.ta_Style = 0; ta.ta_Flags = 0;

font = OpenDiskFont(&ta); if (font) {	CloseFont(font); } }

int main(void) {   openlibs; action; cleanup(0);

return 0; /* keep compiler happy */ }