URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [engine/] [selfont.c] - Blame information for rev 27

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * Copyright (c) 2000 Greg Haerr <greg@censoft.com>
 * Copyright (c) 2000 Morten Rolland
 *
 * Device-independent font selection routines
 */
/*#define NDEBUG*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>              /* toupper*/
#include <string.h>
 
#include "device.h"
#if (UNIX | DOS_DJGPP)
#define strcmpi strcasecmp
#endif
 
#if FONTMAPPER
 
/* entry points*/
int select_font(const PMWLOGFONT plogfont, char *physname);
 
/*
 * The following structure, defines and variables are used to administrate
 * a set of fonts that are scanned when a font is requested.  The set of
 * fonts can be configured with the GdClearFontList and GdAddFont functions.
 */
 
struct available_font {
        MWLOGFONT       lf;
        char *foundry;
        char *family;
        char *fontname;
        int fontclass, alias;
        struct available_font *next;
};
 
static struct available_font *all_fonts = 0;
 
/*
 * Stupid little function to perform a comparison of two strings,
 * returning one of STREQ_EXACT, STREQ_CASE or STREQ_NOMATCH.
 */
#define STREQ_EXACT     0
#define STREQ_CASE      1
#define STREQ_NOMATCH   2
 
static int streq(const char *a, const char *b)
{
        int rc;
 
        for ( rc = STREQ_EXACT;  *a != 0; a++, b++ ) {
                if ( *a == *b )
                        continue;
                if ( toupper((unsigned char)*a) != toupper((unsigned char)*b) )
                        return STREQ_NOMATCH;
                rc = STREQ_CASE;
        }
        if ( *b != 0 )
                return STREQ_NOMATCH;
        return rc;
}
 
/*
 * Decode the "foundry" information into a MWLF_CLASS_ value denoting
 * which rendering system should be used to render the font.
 */
static int decode_font_class(const char *class)
{
        if ( class == NULL )
                return 0;
        if ( !strcmp("T1",class) )
                return MWLF_CLASS_T1LIB;
        if ( !strcmp("FT",class) )
                return MWLF_CLASS_FREETYPE;
        if ( !strcmp("MWF",class) )
                return MWLF_CLASS_BUILTIN;
        return 0;
}
 
/*
 * Try to find a font that matches the foundry and font name
 * requested.
 */
void test_font_naming(const char *foundry, const char *fontname,
                      struct available_font *af,
                      struct available_font **best, int *goodness)
{
        int penalty = 0;
 
        if ( foundry != 0 ) {
                if ( af->foundry != 0 ) {
                        switch ( streq(foundry,af->foundry) ) {
                                case STREQ_EXACT:
                                        break;
                                case STREQ_CASE:
                                        penalty += 2;
                                        break;
                                default:
                                        penalty += 8;
                                        break;
                        }
                } else {
                        penalty += 4;
                }
        }
 
        switch ( streq(fontname,af->fontname) ) {
                case STREQ_EXACT:
                        break;
                case STREQ_CASE:
                        penalty += 1;
                        break;
                default:
                        penalty += 16;
                        break;
        }
 
        if ( *goodness < 0 || penalty < *goodness ) {
                *best = af;
                *goodness = penalty;
        }
}
 
 
/*
 * The 'test_font_goodness' function attempts to find how suitable a font is
 * compared to a desired one.  The desired font is specified by:
 *
 *   foundry (can be NULL), family and the MWLOGFONT
 *   structure (can be NULL).
 *
 * If any fonts are configured, one will always be returned from here,
 * but the goodness may be very bad.  The goodness (or similarity)
 * factor is computed by adding up:
 */
 
#define GOODNESS_NO_FONTNAME            1000    /* No matching font-name found*/
#define GOODNESS_WEIGHT_DIFF            1       /* 0-900 for weight difference*/
 
#define GOODNESS_NO_FOUNDRY             100     /* No foundry */
 
#define GOODNESS_FOUNDRY_UNKNOWN        16      /* Foundry unknown */
#define GOODNESS_CASE_FAMILY            8
#define GOODNESS_CASE_FONTNAME          4
#define GOODNESS_CASE_FOUNDRY           2
#define GOODNESS_EXACT_FAMILY           1       /* Matched font family */
 
#define GOODNESS_EXACT_FOUNDRY          0        /* Clean match */
#define GOODNESS_EXACT_FONTNAME         0        /* Clean match */
 
#define GOODNESS_FAMILY_UNKNOWN         3000
#define GOODNESS_NOMATCH_FAMILY         10000
 
#define GOODNESS_EXACT_FONTFAMILY       0
#define GOODNESS_CASE_FONTFAMILY        32
#define GOODNESS_CLOSE_SLANT            128
#define GOODNESS_BAD_SLANT              256
#define GOODNESS_WRONG_SPACING          2048
 
#define GOODNESS_WRONG_SERIFSTYLE       1024
 
#define GOODNESS_WANTED_SMALLCAPS_NOT_AVAILABLE         4096
#define GOODNESS_ONLY_SMALLCAPS_AVAILABLE               8192
 
 
static int find_foundry_penalty(const struct available_font *have,
                         const char *foundry)
{
        if ( foundry == 0 )
                return 0;
 
        if ( have->foundry == 0 )
                return GOODNESS_FOUNDRY_UNKNOWN;
 
        switch ( streq(foundry,have->foundry) ) {
                case STREQ_EXACT:
                        return GOODNESS_EXACT_FOUNDRY;
                        break;
                case STREQ_CASE:
                        return GOODNESS_CASE_FOUNDRY;
                        break;
                default:
                        return GOODNESS_NO_FOUNDRY;
                        break;
        }
}
 
static int find_family_penalty(const struct available_font *have,
                               const char *family)
{
        if ( family == 0 )
                return 0;
 
        if ( have->family == 0 )
                return GOODNESS_FAMILY_UNKNOWN;
 
        switch ( streq(family,have->family) ) {
                case STREQ_EXACT:
                        return GOODNESS_EXACT_FAMILY;
                        break;
                case STREQ_CASE:
                        return GOODNESS_CASE_FAMILY;
                        break;
                default:
                        return GOODNESS_NOMATCH_FAMILY;
                        break;
        }
}
 
static int find_fontname_penalty(const struct available_font *have,
                                 const char *fontname)
{
        switch ( streq(have->fontname,fontname) ) {
                case STREQ_EXACT:
                        return GOODNESS_EXACT_FONTNAME;
                        break;
                case STREQ_CASE:
                        return GOODNESS_CASE_FONTNAME;
                        break;
                default:
                        break;
        }
 
        /* Test Fontname against font family name */
        if ( have->family != 0 ) {
                switch ( streq(have->family,fontname) ) {
                        case STREQ_EXACT:
                                return GOODNESS_EXACT_FONTFAMILY;
                                break;
                        case STREQ_CASE:
                                return GOODNESS_CASE_FONTFAMILY;
                                break;
                        default:
                                /* No suitable fontname found */
                                break;
                }
        }
        return GOODNESS_NO_FONTNAME;
}
 
static int find_weight_penalty(PMWLOGFONT want, PMWLOGFONT have)
{
        int weight_diff;
 
        weight_diff = want->lfWeight - have->lfWeight;
        if ( weight_diff < 0 )
                weight_diff = -weight_diff;
        return weight_diff * GOODNESS_WEIGHT_DIFF;
}
 
static int find_slant_penalty(PMWLOGFONT want, PMWLOGFONT have)
{
        /* See if slant is acceptable */
 
        if ( !want->lfItalic && !want->lfRoman && !want->lfOblique ) {
                /* Try to default to Romans if not specified */
                if ( have->lfItalic || have->lfOblique )
                        return GOODNESS_CLOSE_SLANT;
                return 0;
        }
 
        if ( want->lfItalic && have->lfItalic )
                return 0;
 
        if ( want->lfRoman && have->lfRoman )
                return 0;
 
        if ( want->lfOblique && have->lfOblique )
                return 0;
 
        /* No perfect match for the slant, try "closest" one */
 
        if ( want->lfItalic && have->lfOblique )
                return GOODNESS_CLOSE_SLANT;
 
        if ( want->lfOblique && have->lfItalic )
                return GOODNESS_CLOSE_SLANT;
 
        return GOODNESS_BAD_SLANT;
}
 
static int find_spacing_penalty(PMWLOGFONT want, PMWLOGFONT have)
{
        if ( want->lfProportional && have->lfProportional )
                return 0;
        if ( want->lfMonospace && have->lfMonospace )
                return 0;
        if ( want->lfMonospace || want->lfProportional )
                return GOODNESS_WRONG_SPACING;
 
        return 0;        /* No special desires */
}
 
static int find_serif_penalty(PMWLOGFONT want, PMWLOGFONT have)
{
        if ( !want->lfSerif && !want->lfSansSerif )
                return 0;
        if ( want->lfSerif && have->lfSerif )
                return 0;
        if ( want->lfSansSerif && have->lfSansSerif )
                return 0;
 
        return GOODNESS_WRONG_SERIFSTYLE;
}
 
static int find_smallcaps_penalty(PMWLOGFONT want, PMWLOGFONT have)
{
        if ( !want->lfSmallCaps && !have->lfSmallCaps )
                return 0;
        if ( want->lfSmallCaps && have->lfSmallCaps )
                return 0;
        if ( want->lfSmallCaps )
                return GOODNESS_WANTED_SMALLCAPS_NOT_AVAILABLE;
        return GOODNESS_ONLY_SMALLCAPS_AVAILABLE;
}
 
 
static void test_font_goodness(const char *foundry, const char *family,
                               const char *fontname, const PMWLOGFONT lf,
                               struct available_font *af,
                               struct available_font **best, int *goodness)
{
        int penalty = 0;
 
        penalty += find_foundry_penalty(af,foundry);
        penalty += find_family_penalty(af,family);
 
        /* Test Fontname, but only if there is no family */
        if ( family == 0 )
                penalty += find_fontname_penalty(af,fontname);
 
        if ( lf != 0 ) {
                /* Check logical font attributes */
                penalty += find_weight_penalty(lf,&af->lf);
                penalty += find_slant_penalty(lf,&af->lf);
                penalty += find_spacing_penalty(lf,&af->lf);
                penalty += find_serif_penalty(lf,&af->lf);
                penalty += find_smallcaps_penalty(lf,&af->lf);
        }
 
        /* See if this font is better than the previous one */
        if ( *goodness < 0 || penalty < *goodness ) {
                /* Yes, this font is better; change to it */
                *best = af;
                *goodness = penalty;
        }
}
 
static struct available_font *find_suitable_font(const char *foundry,
                                               const char *fontname,
                                               const PMWLOGFONT plogfont)
{
        struct available_font *af, *best;
        char *family;
        int goodness;
 
        /*
         * Try to find a font that matches the name specified as the
         * desired font (and foundry if possible).  If we find a
         * suitable font, we will use the family name when trying to
         * find a font that matches the MWLOGFONT attributes.  This
         * makes it possible to ask for an Italic version of
         * "Times Roman" and the expected thing will happen (get the
         * font "Times Italic").
         */
        goodness = -1;
        for ( af = best = all_fonts; af != 0; af = af->next ) {
                test_font_naming(foundry,fontname,af,&best,&goodness);
        }
        family = 0;
        if ( goodness != -1 ) {
                /* A font with a name that kind of matched was found,
                 * make a note of its family.  If it has no family, we
                 * can't make any use of the
                 */
                family = best->family;
        }
 
        /*
         * Try to find the closest font that matches the font family
         * we have established.  If no family was found above, all
         * fonts will be considered.
         */
        goodness = -1;
        for ( af = best = all_fonts; af != 0; af = af->next ) {
                test_font_goodness(foundry,family,fontname,plogfont,af,
                                   &best,&goodness);
        }
 
        return best;
}
 
 
int select_font(const PMWLOGFONT plogfont, char *physname)
{
        struct available_font *font;
        char fndry[128], *foundry;
        const char *fontname;
        char *tmp;
        int t, comma;
        int fontclass = 0;
        int found_font = 0;
 
        fontname = plogfont->lfFaceName;
 
        for ( t=0; t < 20; t++ ) {
                /* Only follow 20 aliases deep, assume failure if more ... */
 
                /* Find foundry for the current font */
                foundry = NULL;
                if ( (tmp = index(fontname,',')) != NULL ) {
                        /*
                         * We have a font name like T1,c0934345 or
                         * Adobe,Times (e.g. it includes foundry or
                         * rendering method).  Separate them here.
                         */
                        comma = tmp - fontname;
                        tmp++;
                        strncpy(fndry,fontname,comma);
                        fndry[comma] = '\0';
                        foundry = fndry;
                        fontname = tmp;
                }
 
                fontclass = decode_font_class(foundry);
 
                if ( plogfont == NULL && fontclass == 0 )
                        fontclass = MWLF_CLASS_BUILTIN;
 
                if ( fontclass ) {
                        /* The font is a "physical" font, use it directly */
                        strcpy(physname,fontname);
                        return fontclass;
                }
 
                if ( found_font ) {
                        /* Oops, should not get here, unless a font definition
                         * resulted in a non-existent font, e.g. the fontclass
                         * is unknown.
                         */
                        goto default_font;
                }
 
                font = find_suitable_font(foundry,fontname,plogfont);
 
                if ( font == NULL ) {
                        goto default_font;
                }
 
                if ( !font->alias )
                        found_font = 1;
 
                fontname = font->lf.lfFaceName;
        }
 
 default_font:
 
        strcpy(physname, MWFONT_SYSTEM_VAR);
        return MWLF_CLASS_BUILTIN;
}
 
/* This function can be used to clear the existing, possibly default list
 * of fonts on the system.  This is typically done before reading a
 * configuration file that defines the available fonts.
 */
void
GdClearFontList(void)
{
        struct available_font *font, *next_font;
 
        font = all_fonts;
        while ( font != 0 ) {
                next_font = font->next;
                if ( font->foundry != 0 )
                        free(font->foundry);
                if ( font->family != 0 )
                        free(font->family);
                free(font->fontname);
                free(font);
                font = next_font;
        }
 
        all_fonts = 0;
}
 
/* This function will add a font to the list of available fonts.
 * The physical name is the name as used by the underlying font
 * rendering engine.
 */
int
GdAddFont(char *fndry, char *fmly, char *fontname, PMWLOGFONT lf,
        unsigned int flags)
{
        struct available_font *font, *walk;
        int fontclass = 0;
        char *physname = lf->lfFaceName;
 
        if ( !strncmp(physname,"T1,",3) ) {
#ifdef HAVE_T1LIB_SUPPORT
                /* Can handle Type 1 fonts */
                physname += 3;
                fontclass = MWLF_CLASS_T1LIB;
                goto do_font;
#else
                /* Can't handle Type 1 fonts */
                return -1;
#endif
        }
 
        if ( !strncmp(physname,"FT,",3) ) {
#if HAVE_FREETYPE_SUPPORT
                /* Can handle FreeType fonts */
                physname += 3;
                fontclass = MWLF_CLASS_FREETYPE;
                goto do_font;
#else
                /* Can't handle Type 1 fonts */
                return -1;
#endif
        }
 
        if ( !strncmp(physname,"MWF,",4) ) {
                /* This is a Microwindows built in font */
                physname += 4;
                fontclass = MWLF_CLASS_BUILTIN;
                goto do_font;
        }
 
        /* Only aliases does not need to use T1, FT or MWF description */
        if ( !(flags & MWLF_FLAGS_ALIAS) )
                return -1;
 
 do_font:
 
        font = malloc(sizeof(*font));
        if ( font == 0 )
                return -1;
 
        font->foundry = 0;
        if ( strcmp("-",fndry) ) {
                font->foundry = strdup(fndry);
                if ( font->foundry == 0 ) {
                        free(font);
                        return -1;
                }
        }
 
        font->family = 0;
        if ( strcmp("-",fmly) ) {
                font->family = strdup(fmly);
                if ( font->family == 0 ) {
                        free(font->foundry);
                        free(font);
                        return -1;
                }
        }
 
        font->fontname = strdup(fontname);
        if ( font->fontname == 0 ) {
                free(font->foundry);
                free(font->family);
                free(font);
                return -1;
        }
 
        memcpy(&font->lf,lf,sizeof(*lf));
 
        printf("Adding font: '%s' '%s' '%s' '%s'\n",font->foundry,
               font->family,font->fontname,font->lf.lfFaceName);
 
        font->next = 0;
        font->alias = (flags & MWLF_FLAGS_ALIAS) ? 1 : 0;
        font->fontclass = fontclass;
 
        /* Stupid append at end of list code */
        if ( all_fonts == 0 ) {
                all_fonts = font;
        } else {
                for ( walk = all_fonts; walk->next != 0; walk = walk->next )
                        ;
                walk->next = font;
        }
 
        return 0;
}
 
/*
 * These functions are used to set attributes in a logical font
 * structure, called through a table of function pointers.
 */
static void font_set_light(PMWLOGFONT lf)
        { lf->lfWeight = MWLF_WEIGHT_LIGHT; }
static void font_set_regular(PMWLOGFONT lf)
        { lf->lfWeight = MWLF_WEIGHT_REGULAR; }
static void font_set_medium(PMWLOGFONT lf)
        { lf->lfWeight = MWLF_WEIGHT_MEDIUM; }
static void font_set_demibold(PMWLOGFONT lf)
        { lf->lfWeight = MWLF_WEIGHT_DEMIBOLD; }
static void font_set_bold(PMWLOGFONT lf)
        { lf->lfWeight = MWLF_WEIGHT_BOLD; }
static void font_set_black(PMWLOGFONT lf)
        { lf->lfWeight = MWLF_WEIGHT_BLACK; }
 
static void font_set_italic(PMWLOGFONT lf) { lf->lfItalic = 1; }
static void font_set_roman(PMWLOGFONT lf) { lf->lfRoman = 1; }
static void font_set_oblique(PMWLOGFONT lf) { lf->lfOblique = 1; }
 
static void font_set_normal(PMWLOGFONT lf)
        { lf->lfPitch = MWLF_PITCH_NORMAL; }
static void font_set_semicondensed(PMWLOGFONT lf)
        { lf->lfPitch = MWLF_PITCH_SEMICONDENSED; }
static void font_set_condensed(PMWLOGFONT lf)
        { lf->lfPitch = MWLF_PITCH_CONDENSED; }
 
static void font_set_serif(PMWLOGFONT lf) { lf->lfSerif = 1; }
static void font_set_sansserif(PMWLOGFONT lf) { lf->lfSansSerif = 1; }
static void font_set_monospace(PMWLOGFONT lf) { lf->lfMonospace = 1; }
static void font_set_proportional(PMWLOGFONT lf) { lf->lfProportional = 1; }
 
int config_font(char *file, int line, int argc, char *argv[])
{
        unsigned int flags = 0;
        MWLOGFONT lf;
        char tmp[512];
        char *p, *q, *fndry, *family, *fontname;
        int size, t;
 
        static struct {
                char *name;
                void (*function)(PMWLOGFONT lf);
        } attrs[] = {
                /* Weight */
                { "Light",              font_set_light },
                { "Regular",            font_set_regular },
                { "Medium",             font_set_medium },
                { "DemiBold",           font_set_demibold },
                { "Demibold",           font_set_demibold },
                { "Bold",               font_set_bold },
                { "Black",              font_set_black },
 
                /* Slant */
                { "Italic",             font_set_italic },
                { "Italics",            font_set_italic },
                { "Roman",              font_set_roman },
                { "Oblique",            font_set_oblique },
 
                /* Width */
                { "Normal",             font_set_normal },
                { "Semicondensed",      font_set_semicondensed },
                { "Condensed",          font_set_condensed },
 
                /* Class */
                { "Serif",              font_set_serif },
                { "Sans-serif",         font_set_sansserif },
                { "Monospace",          font_set_monospace },
                { "Proportional",       font_set_proportional },
 
                { 0, 0 }
        };
 
        MWLF_Clear(&lf);
 
        if ( argc != 6 ) {
                fprintf(stderr,"Bad font description %s:%d\n",file,line);
                return 1;
        }
 
        if ( !strcmp("alias",argv[1]) ) {
                flags |= MWLF_FLAGS_ALIAS;
                fndry = "-";
        } else {
                fndry = argv[1];
        }
 
        family = argv[2];
        fontname = argv[3];
        strcpy(lf.lfFaceName,argv[5]);
        p = argv[4];
 
        while ( *p != '\0' ) {
                /* Parse attributes */
                q = strchr(p,',');
                if ( q != 0 ) {
                        size = q - p;
                        strncpy(tmp,p,size);
                        tmp[size] = '\0';
                        p = q + 1;
                } else {
                        strcpy(tmp,p);
                        p += strlen(tmp);
                }
 
                for ( t = 0; attrs[t].name != 0; t++ ) {
                        if ( !strcmp(attrs[t].name,tmp) ) {
                                attrs[t].function(&lf);
                                goto next;
                        }
                }
 
                fprintf(stderr,"No such font attribute '%s' in %s:%d\n",
                        tmp,file,line);
                return 1;
 
        next: ;
        }
 
        GdAddFont(fndry,family,fontname,&lf,flags);
 
        return 0;
}
 
/*
 * Handle a single configuration line entery.  Arguments as for
 * function 'main(int argc, char **argv)' -- argv[0] is name of
 * original configuration file.  Return negative value for error,
 * zero for OK.
 */
 
int config_line(char *file, int line, int argc, char *argv[])
{
        if ( !argc )
                return 0;        /* Empty line */
 
        if ( argv[0][0] == '#' )
                return 0;        /* Comment line */
 
        if ( !strcmp("font", argv[0]) )
                return config_font(file,line,argc,argv);
 
        if ( !strcmp("clear-fonts", argv[0]) ) {
                GdClearFontList();
                return 0;
        }
 
        return -1;
}
 
 
/*
 * Read (one of) the configuration files.
 */
#define MAXCONFIGLINESIZE       1024
#define MAXCONFIGELEMENTS         64
 
int read_configfile(char *file)
{
        FILE *cf;
        char buffer[MAXCONFIGLINESIZE+1];
        char *args[MAXCONFIGELEMENTS+1];
        unsigned char *p;
        int argc, s, rc, t, line;
 
        if ( (cf = fopen(file,"r")) == 0 ) {
                fprintf(stderr,"Unable to read config file '%s'\n",file);
                return -1;
        }
 
        line = 0;
        while ( !feof(cf) ) {
                if ( fgets(buffer,1000,cf) == 0 )
                        break;
                line++;
                s = strlen(buffer) - 1;
                while ( s >= 0 && buffer[s] == '\n' )
                        buffer[s--] = '\0';
                p = (unsigned char *)buffer;
                argc = 0;
                for ( t=0; t < MAXCONFIGELEMENTS; t++ ) {
                        while ( *p != '\0' && isspace(*p) )
                                p++;
                        if ( *p == '\"' ) {
                                /* Quoted string */
                                p++;
                                args[t] = p;
                                argc++;
                                while ( *p != '\0' && *p != '\"' )
                                        p++;
                                if ( *p == '\0' ) {
                                        fprintf(stderr,"Unbalanced quotes in %s:%d\n",
                                                file,line);
                                        break;
                                }
                                *p++ = '\0';
                        } else {
                                if ( *p == '\0' )
                                        break;
                                args[t] = p;
                                argc++;
                                while ( *p != '\0' && !isspace(*p) )
                                        p++;
                                *p++ = '\0';
                        }
                }
#if 0
                {
                        int t;
                        for ( t=0; t < argc; t++ )
                                printf("#%d: '%s'\n",t,args[t]);
                }
#endif
                rc = config_line(file, line, argc, args);
                if ( rc < 0 )
                        return rc;
        }
 
        fclose(cf);
 
        return 0;
}
#endif /* FONTMAPPER*/
Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [services/] [gfx/] [mw/] [v2_0/] [src/] [engine/] [selfont.c] - Blame information for rev 27

Line No.	Rev	Author	Line
1	27	unneback	`/*`
2			`* Copyright (c) 2000 Greg Haerr <greg@censoft.com>`
3			`* Copyright (c) 2000 Morten Rolland`
4			`*`
5			`* Device-independent font selection routines`
6			`*/`
7			`/#define NDEBUG/`
8			`#include <stdio.h>`
9			`#include <stdlib.h>`
10			`#include <string.h>`
11			`#include <assert.h>`
12			`#include <ctype.h> /* toupper*/`
13			`#include <string.h>`
14
15			`#include "device.h"`
16			`#if (UNIX \| DOS_DJGPP)`
17			`#define strcmpi strcasecmp`
18			`#endif`
19
20			`#if FONTMAPPER`
21
22			`/* entry points*/`
23			`int select_font(const PMWLOGFONT plogfont, char *physname);`
24
25			`/*`
26			`* The following structure, defines and variables are used to administrate`
27			`* a set of fonts that are scanned when a font is requested. The set of`
28			`* fonts can be configured with the GdClearFontList and GdAddFont functions.`
29			`*/`
30
31			`struct available_font {`
32			`MWLOGFONT lf;`
33			`char *foundry;`
34			`char *family;`
35			`char *fontname;`
36			`int fontclass, alias;`
37			`struct available_font *next;`
38			`};`
39
40			`static struct available_font *all_fonts = 0;`