gnu/usr.bin/groff/libXdvi/font.c

   1 /*
   2  * font.c
   3  *
   4  * map dvi fonts to X fonts
   5  */
   6
   7 #include <X11/Xos.h>
   8 #include <X11/IntrinsicP.h>
   9 #include <X11/StringDefs.h>
  10 #include <stdio.h>
  11 #include <ctype.h>
  12 #include "DviP.h"
  13 #include "XFontName.h"
  14
  15 extern char     *malloc ();
  16
  17 static char *
  18 savestr (s)
  19         char    *s;
  20 {
  21         char    *n;
  22
  23         if (!s)
  24                 return 0;
  25         n = malloc (strlen (s) + 1);
  26         if (n)
  27                 strcpy (n, s);
  28         return n;
  29 }
  30
  31 static DviFontList *
  32 LookupFontByPosition (dw, position)
  33         DviWidget       dw;
  34         int             position;
  35 {
  36         DviFontList     *f;
  37
  38         for (f = dw->dvi.fonts; f; f=f->next)
  39                 if (f->dvi_number == position)
  40                         break;
  41         return f;
  42 }
  43
  44 static DviFontSizeList *
  45 LookupFontSizeBySize (f, size)
  46         DviFontList     *f;
  47         int             size;
  48 {
  49         DviFontSizeList *fs, *best = 0;
  50         int             bestsize = 0;
  51
  52         for (fs = f->sizes; fs; fs=fs->next) {
  53                 if (fs->size <= size && fs->size >= bestsize) {
  54                         best = fs;
  55                         bestsize = fs->size;
  56                 }
  57         }
  58         return best;
  59 }
  60
  61 static char *
  62 SkipFontNameElement (n)
  63         char    *n;
  64 {
  65         while (*n != '-')
  66                 if (!*++n)
  67                         return 0;
  68         return n+1;
  69 }
  70
  71 # define SizePosition           8
  72 # define EncodingPosition       13
  73
  74 static
  75 ConvertFontNameToSize (n)
  76         char    *n;
  77 {
  78         int     i, size;
  79
  80         for (i = 0; i < SizePosition; i++) {
  81                 n = SkipFontNameElement (n);
  82                 if (!n)
  83                         return -1;
  84         }
  85         size = atoi (n);
  86         return size/10;
  87 }
  88
  89 static char *
  90 ConvertFontNameToEncoding (n)
  91         char    *n;
  92 {
  93         int i;
  94         for (i = 0; i < EncodingPosition; i++) {
  95                 n = SkipFontNameElement (n);
  96                 if (!n)
  97                         return 0;
  98         }
  99         return n;
 100 }
 101
 102 DviFontSizeList *
 103 InstallFontSizes (dw, x_name)
 104         DviWidget       dw;
 105         char            *x_name;
 106 {
 107         char    fontNameString[2048];
 108         char    **fonts;
 109         int     i, count;
 110         int     size;
 111         DviFontSizeList *sizes, *new;
 112         XFontName       fontName;
 113         unsigned int    fontNameAttributes;
 114
 115         if (!XParseFontName (x_name, &fontName, &fontNameAttributes))
 116                 return;
 117         fontNameAttributes &= ~(FontNamePixelSize|FontNamePointSize);
 118         fontNameAttributes |= FontNameResolutionX;
 119         fontNameAttributes |= FontNameResolutionY;
 120         fontName.ResolutionX = dw->dvi.device_resolution;
 121         fontName.ResolutionY = dw->dvi.device_resolution;
 122         XFormatFontName (&fontName, fontNameAttributes, fontNameString);
 123         fonts = XListFonts (XtDisplay (dw), fontNameString, 10000000, &count);
 124         sizes = 0;
 125         for (i = 0; i < count; i++) {
 126                 if ((size = ConvertFontNameToSize (fonts[i])) != -1) {
 127                         new = (DviFontSizeList *) malloc (sizeof *new);
 128                         new->next = sizes;
 129                         new->size = size;
 130                         new->x_name = savestr (fonts[i]);
 131                         new->doesnt_exist = 0;
 132                         new->font = 0;
 133                         sizes = new;
 134                 }
 135         }
 136         XFreeFontNames (fonts);
 137         return sizes;
 138 }
 139
 140 static
 141 DisposeFontSizes (fs)
 142         DviFontSizeList *fs;
 143 {
 144         DviFontSizeList *next;
 145
 146         for (; fs; fs=next) {
 147                 next = fs->next;
 148                 if (fs->x_name)
 149                         free (fs->x_name);
 150                 if (fs->font)
 151                         XFree ((char *)fs->font);
 152                 free ((char *) fs);
 153         }
 154 }
 155
 156 static DviFontList *
 157 InstallFont (dw, position, dvi_name, x_name)
 158         DviWidget       dw;
 159         int             position;
 160         char            *dvi_name;
 161         char            *x_name;
 162 {
 163         DviFontList     *f;
 164         DviFontSizeList *sizes;
 165         char            *encoding;
 166
 167         if (f = LookupFontByPosition (dw, position)) {
 168                 /*
 169                  * ignore gratuitous font loading
 170                  */
 171                 if (!strcmp (f->dvi_name, dvi_name) &&
 172                     !strcmp (f->x_name, x_name))
 173                         return;
 174
 175                 sizes = InstallFontSizes (dw, x_name);
 176                 if (!sizes)
 177                     return f;
 178
 179                 DisposeFontSizes (f->sizes);
 180                 if (f->dvi_name)
 181                         free (f->dvi_name);
 182                 if (f->x_name)
 183                         free (f->x_name);
 184         } else {
 185                 sizes = InstallFontSizes (dw, x_name);
 186                 if (!sizes)
 187                     return 0;
 188                 f = (DviFontList *) malloc (sizeof (*f));
 189                 f->next = dw->dvi.fonts;
 190                 dw->dvi.fonts = f;
 191         }
 192         f->dvi_name = savestr (dvi_name);
 193         f->x_name = savestr (x_name);
 194         f->dvi_number = position;
 195         f->sizes = sizes;
 196         if (f->x_name) {
 197                 encoding = ConvertFontNameToEncoding (f->x_name);
 198                 f->char_map = DviFindMap (encoding);
 199         } else
 200                 f->char_map = 0;
 201         /*
 202          * force requery of fonts
 203          */
 204         dw->dvi.font = 0;
 205         dw->dvi.font_number = -1;
 206         dw->dvi.cache.font = 0;
 207         dw->dvi.cache.font_number = -1;
 208         return f;
 209 }
 210
 211 static char *
 212 MapDviNameToXName (dw, dvi_name)
 213         DviWidget       dw;
 214         char            *dvi_name;
 215 {
 216         DviFontMap      *fm;
 217
 218         for (fm = dw->dvi.font_map; fm; fm=fm->next)
 219                 if (!strcmp (fm->dvi_name, dvi_name))
 220                         return fm->x_name;
 221         return 0;
 222 }
 223
 224 static char *
 225 MapXNameToDviName (dw, x_name)
 226         DviWidget       dw;
 227         char            *x_name;
 228 {
 229         DviFontMap      *fm;
 230
 231         for (fm = dw->dvi.font_map; fm; fm=fm->next)
 232                 if (!strcmp (fm->x_name, x_name))
 233                         return fm->dvi_name;
 234         return 0;
 235 }
 236
 237 ParseFontMap (dw)
 238         DviWidget       dw;
 239 {
 240         char            dvi_name[1024];
 241         char            x_name[2048];
 242         char            *m, *s;
 243         char            *encoding;
 244         DviFontMap      *fm, *new;
 245
 246         if (dw->dvi.font_map)
 247                 DestroyFontMap (dw->dvi.font_map);
 248         fm = 0;
 249         m = dw->dvi.font_map_string;
 250         while (*m) {
 251                 s = m;
 252                 while (*m && !isspace (*m))
 253                         ++m;
 254                 strncpy (dvi_name, s, m-s);
 255                 dvi_name[m-s] = '\0';
 256                 while (isspace (*m))
 257                         ++m;
 258                 s = m;
 259                 while (*m && *m != '\n')
 260                         ++m;
 261                 strncpy (x_name, s, m-s);
 262                 x_name[m-s] = '\0';
 263                 new = (DviFontMap *) malloc (sizeof *new);
 264                 new->x_name = savestr (x_name);
 265                 new->dvi_name = savestr (dvi_name);
 266                 new->next = fm;
 267                 fm = new;
 268                 ++m;
 269         }
 270         dw->dvi.font_map = fm;
 271 }
 272
 273 DestroyFontMap (font_map)
 274         DviFontMap      *font_map;
 275 {
 276         DviFontMap      *next;
 277
 278         for (; font_map; font_map = next) {
 279                 next = font_map->next;
 280                 if (font_map->x_name)
 281                         free (font_map->x_name);
 282                 if (font_map->dvi_name)
 283                         free (font_map->dvi_name);
 284                 free ((char *) font_map);
 285         }
 286 }
 287
 288 SetFontPosition (dw, position, dvi_name, extra)
 289         DviWidget       dw;
 290         int             position;
 291         char            *dvi_name;
 292         char            *extra; /* unused */
 293 {
 294         char    *x_name;
 295
 296         x_name = MapDviNameToXName (dw, dvi_name);
 297         (void) InstallFont (dw, position, dvi_name, x_name);
 298 }
 299
 300 XFontStruct *
 301 QueryFont (dw, position, size)
 302         DviWidget       dw;
 303         int             position;
 304         int             size;
 305 {
 306         DviFontList     *f;
 307         DviFontSizeList *fs;
 308
 309         f = LookupFontByPosition (dw, position);
 310         if (!f)
 311                 return dw->dvi.default_font;
 312         fs = LookupFontSizeBySize (f, size);
 313         if (!fs->font) {
 314                 if (fs->x_name)
 315                         fs->font = XLoadQueryFont (XtDisplay (dw), fs->x_name);
 316                 if (!fs->font)
 317                         fs->font = dw->dvi.default_font;
 318         }
 319         return fs->font;
 320 }
 321
 322 DviCharNameMap *
 323 QueryFontMap (dw, position)
 324         DviWidget       dw;
 325         int             position;
 326 {
 327         DviFontList     *f;
 328         char            *encoding;
 329
 330         f = LookupFontByPosition (dw, position);
 331         if (f)
 332             return f->char_map;
 333         else
 334             return 0;
 335 }
 336
 337 LoadFont (dw, position, size)
 338         DviWidget       dw;
 339         int             position;
 340         int             size;
 341 {
 342         XFontStruct     *font;
 343
 344         font = QueryFont (dw, position, size);
 345         dw->dvi.font_number = position;
 346         dw->dvi.font_size = size;
 347         dw->dvi.font = font;
 348         XSetFont (XtDisplay (dw), dw->dvi.normal_GC, font->fid);
 349         return;
 350 }