font.c

   1 /* font handling */
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include "post.h"
   6
   7 struct font {
   8         char name[FNLEN];
   9         char fontname[FNLEN];
  10         char fontpath[1024];
  11         int spacewid;
  12         struct glyph *gl;               /* glyphs present in the font */
  13         int gl_n, gl_sz;                /* number of glyphs in the font */
  14         struct dict *gl_dict;           /* mapping from gl[i].id to i */
  15         struct dict *ch_dict;           /* charset mapping */
  16         struct dict *ch_map;            /* character aliases */
  17 };
  18
  19 /* find a glyph by its name */
  20 struct glyph *font_find(struct font *fn, char *name)
  21 {
  22         int i = dict_get(fn->ch_dict, name);
  23         if (i < 0)      /* maybe a character alias */
  24                 i = dict_get(fn->ch_map, name);
  25         return i >= 0 ? fn->gl + i : NULL;
  26 }
  27
  28 /* find a glyph by its device-dependent identifier */
  29 struct glyph *font_glyph(struct font *fn, char *id)
  30 {
  31         int i = dict_get(fn->gl_dict, id);
  32         return i >= 0 ? &fn->gl[i] : NULL;
  33 }
  34
  35 static int font_glyphput(struct font *fn, char *id, char *name, int type)
  36 {
  37         struct glyph *g;
  38         if (fn->gl_n == fn->gl_sz) {
  39                 fn->gl_sz = fn->gl_sz + 1024;
  40                 fn->gl = mextend(fn->gl, fn->gl_n, fn->gl_sz, sizeof(fn->gl[0]));
  41         }
  42         g = &fn->gl[fn->gl_n];
  43         strcpy(g->id, id);
  44         strcpy(g->name, name);
  45         g->type = type;
  46         g->font = fn;
  47         dict_put(fn->gl_dict, g->id, fn->gl_n);
  48         return fn->gl_n++;
  49 }
  50
  51 static void tilleol(FILE *fin, char *s)
  52 {
  53         int c = fgetc(fin);
  54         while (c != EOF && c != '\n') {
  55                 *s++ = c;
  56                 c = fgetc(fin);
  57         }
  58         *s = '\0';
  59         if (c != EOF)
  60                 ungetc(c, fin);
  61 }
  62
  63 static int font_readchar(struct font *fn, FILE *fin, int *n, int *gid)
  64 {
  65         struct glyph *g;
  66         char tok[ILNLEN];
  67         char name[ILNLEN];
  68         char id[ILNLEN];
  69         int type;
  70         if (fscanf(fin, "%s %s", name, tok) != 2)
  71                 return 1;
  72         if (!strcmp("---", name))
  73                 sprintf(name, "c%04d", *n);
  74         if (strcmp("\"", tok)) {
  75                 if (fscanf(fin, "%d %s", &type, id) != 2)
  76                         return 1;
  77                 *gid = dict_get(fn->gl_dict, id);
  78                 if (*gid < 0) {
  79                         *gid = font_glyphput(fn, id, name, type);
  80                         g = &fn->gl[*gid];
  81                         sscanf(tok, "%d", &g->wid);
  82                         tilleol(fin, tok);
  83                         if (sscanf(tok, "%d", &g->pos) != 1)
  84                                 g->pos = 0;
  85                 }
  86                 dict_put(fn->ch_dict, name, *gid);
  87                 (*n)++;
  88         } else {
  89                 dict_put(fn->ch_map, name, *gid);
  90         }
  91         return 0;
  92 }
  93
  94 static void skipline(FILE* filp)
  95 {
  96         int c;
  97         do {
  98                 c = getc(filp);
  99         } while (c != '\n' && c != EOF);
 100 }
 101
 102 struct font *font_open(char *path)
 103 {
 104         struct font *fn;
 105         int ch_g = -1;          /* last glyph in the charset */
 106         int ch_n = 0;                   /* number of glyphs in the charset */
 107         char tok[ILNLEN];
 108         FILE *fin;
 109         fin = fopen(path, "r");
 110         if (!fin)
 111                 return NULL;
 112         fn = malloc(sizeof(*fn));
 113         if (!fn) {
 114                 fclose(fin);
 115                 return NULL;
 116         }
 117         memset(fn, 0, sizeof(*fn));
 118         fn->gl_dict = dict_make(-1, 1);
 119         fn->ch_dict = dict_make(-1, 1);
 120         fn->ch_map = dict_make(-1, 1);
 121         while (fscanf(fin, "%s", tok) == 1) {
 122                 if (!strcmp("char", tok)) {
 123                         font_readchar(fn, fin, &ch_n, &ch_g);
 124                 } else if (!strcmp("spacewidth", tok)) {
 125                         fscanf(fin, "%d", &fn->spacewid);
 126                 } else if (!strcmp("name", tok)) {
 127                         fscanf(fin, "%s", fn->name);
 128                 } else if (!strcmp("fontname", tok)) {
 129                         fscanf(fin, "%s", fn->fontname);
 130                 } else if (!strcmp("fontpath", tok)) {
 131                         int c = fgetc(fin);
 132                         while (c == ' ')
 133                                 c = fgetc(fin);
 134                         ungetc(c, fin);
 135                         tilleol(fin, fn->fontpath);
 136                 } else if (!strcmp("ligatures", tok)) {
 137                         while (fscanf(fin, "%s", tok) == 1)
 138                                 if (!strcmp("0", tok))
 139                                         break;
 140                 } else if (!strcmp("charset", tok)) {
 141                         while (!font_readchar(fn, fin, &ch_n, &ch_g))
 142                                 ;
 143                         break;
 144                 }
 145                 skipline(fin);
 146         }
 147         fclose(fin);
 148         return fn;
 149 }
 150
 151 void font_close(struct font *fn)
 152 {
 153         dict_free(fn->gl_dict);
 154         dict_free(fn->ch_dict);
 155         dict_free(fn->ch_map);
 156         free(fn->gl);
 157         free(fn);
 158 }
 159
 160 /* return width w for the given font and size */
 161 int font_wid(struct font *fn, int sz, int w)
 162 {
 163         return (w * sz + dev_uwid / 2) / dev_uwid;
 164 }
 165
 166 /* space width for the give word space or sentence space */
 167 int font_swid(struct font *fn, int sz)
 168 {
 169         return font_wid(fn, sz, fn->spacewid);
 170 }
 171
 172 char *font_name(struct font *fn)
 173 {
 174         return fn->fontname;
 175 }
 176
 177 char *font_path(struct font *fn)
 178 {
 179         return fn->fontpath;
 180 }
 181
 182 int font_glnum(struct font *fn, struct glyph *g)
 183 {
 184         return g - fn->gl;
 185 }
 186
 187 struct glyph *font_glget(struct font *fn, int id)
 188 {
 189         return id >= 0 && id < fn->gl_n ? &fn->gl[id] : NULL;
 190 }