![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to font.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / libsrc|
Return to font.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libibm / libsrc |
1.1 root 1: #ifndef lint
2: static char *rcsid_font_c = "$Header: font.c,v 10.1 86/11/19 10:41:45 jg Exp $";
3: #endif lint
4: /* Copyright 1985 Massachusetts Institute of Technology */
5:
6: /* font.c - Reads a font from a file and stores it on the workstation
7: *
8: * GetFont Takes a font name and opens it
9: * FreeFont Frees the storage taken by a font
10: * StrikeToBitmaps converts strike format into an array of individual
11: * character bitmaps
12: *
13: * Changes and additions by:
14: *
15: * Scott Bates
16: * Brown University
17: * IRIS, Box 1946
18: * Providence, RI 02912
19: *
20: *
21: * Copyright (c) 1986 Brown University
22: *
23: * Permission to use, copy, modify and distribute this software and its
24: * documentation for any purpose and without fee is hereby granted, provided
25: * that the above copyright notice appear in all copies, and that both
26: * that copyright notice and this permission notice appear in supporting
27: * documentation, and that the name of Brown University not be used in
28: * advertising or publicity pertaining to distribution of the software
29: * without specific, written prior permission. Brown University makes no
30: * representations about the suitability of this software for any purpose.
31: * It is provided "as-is" without express or implied warranty.
32: */
33:
34: #include "private.h"
35: #include "bitblt.h"
36: #include "xsite.h"
37: #include "font.h"
38:
39: /*
40: * Open font file
41: */
42:
43: FONT *GetFont (name)
44: char *name;
45: {
46: char fontname[256];
47: int fontfile;
48: FontData fd;
49: #define chars ((BitMap *) fd.f_characters)
50: int fontsize, leftsize, width;
51: register i, j;
52: BITMAP *strike_bm;
53: char *fontarea;
54: int VisibleChars = 0;
55: register short *leftarea, *leftarray;
56: register FONT *font;
57: register FontPriv *fpriv;
58: int tablesize = CHARPERFONT * sizeof(short);
59:
60: #ifdef TRACE_X
61: fprintf(stderr, "In GetFont\n");
62: fflush(stderr);
63: #endif TRACE_X
64:
65: /*
66: * Convert font name into full path name
67: */
68:
69: strcpy (fontname, DEFAULT_FONT_DIRECTORY);
70: strcat (fontname, name);
71: strcat (fontname, DEFAULT_FONT_SUFFIX);
72:
73: /*
74: * Open font file
75: */
76:
77: if ((fontfile = open (fontname, 0)) == -1 &&
78: (errno != ENOENT || (fontfile = open (name, 0)) == -1)) {
79: errno = EINVAL;
80: return (NULL);
81: }
82:
83: /*
84: * Read in font data structure
85: */
86:
87: if (read (fontfile, (caddr_t) &fd, sizeof (FontData))
88: != sizeof(FontData)) {
89: close (fontfile);
90: errno = EINVAL;
91: return (NULL);
92: }
93:
94: /*
95: * Swap each of the shorts in font data structure.
96: * font was created on a VAX and needs to be swapped
97: * for this hardware.
98: */
99:
100: Swap_shorts((short *) &fd, sizeof(FontData) / sizeof(short));
101:
102: /*
103: * Allocate space for font bitmap.
104: * bitmap is in strike format.
105: */
106:
107: fontsize = BitmapSize(chars->bm_width, chars->bm_height);
108: fontarea = (char *) Xalloc (fontsize);
109:
110: /*
111: * Read font bitmap into allocated area
112: */
113:
114: lseek (fontfile, (long) fd.f_characters[0], 0);
115: if (read (fontfile, fontarea, fontsize) != fontsize) {
116: close (fontfile);
117: free (fontarea);
118: errno = EINVAL;
119: return (NULL);
120: }
121:
122: /*
123: * Reverse all the bits in each character of font bitmap.
124: * The font bitmap was created on VAX and needs to be
125: * reversed for this hardware.
126: */
127:
128: ReverseCharBits(fontarea, fontsize);
129:
130: /*
131: * Allocate space for left array and width table
132: */
133:
134: leftarea = (short *) Xalloc (tablesize);
135: bzero((caddr_t)leftarea, tablesize);
136: leftarray = (short *) Xalloc (tablesize);
137:
138: /*
139: * What kind of font is this ?
140: */
141:
142: if (fd.f_fixedWidth == 0) {
143: /*
144: * The font is variable width so allocate space for left
145: * array and read it in. The left array is an array
146: * of pointers to the left most bit of each character
147: * in the font.
148: */
149:
150: leftsize = (fd.f_lastChar - fd.f_firstChar + 2)
151: * sizeof (short);
152: lseek (fontfile, (long) fd.f_leftArray[0], 0);
153: if (read(fontfile,(caddr_t)&leftarea[fd.f_firstChar],leftsize)
154: != leftsize) {
155: close (fontfile);
156: free (fontarea);
157: free ((caddr_t) leftarea);
158: free ((caddr_t) leftarray);
159: errno = EINVAL;
160: return (NULL);
161: }
162:
163: /*
164: * Swap each short in the leftarray. The array was created
165: * on a VAX and needs to be swapped for this hardware
166: */
167:
168: Swap_shorts(leftarea, leftsize / sizeof (short));
169: } else {
170: /*
171: * The font is of a fixed width so create the left
172: * array ourselves
173: */
174:
175: j = 0;
176: for (i = fd.f_firstChar; i <= fd.f_lastChar + 1; i++) {
177: leftarea[i] = j;
178: j += fd.f_fixedWidth;
179: }
180: }
181:
182: /*
183: * Make a copy of the left array for future use
184: */
185:
186: bcopy(leftarea, leftarray, tablesize);
187:
188: /*
189: * Close the font file
190: */
191:
192: close (fontfile);
193:
194: /*
195: * Allocate space for FONT structure
196: */
197:
198: font = (FONT *) Xalloc (sizeof (FONT));
199:
200: /*
201: * Fill in FONT structure with data obtained from font file
202: */
203:
204: font->height = chars->bm_height;
205: font->first = fd.f_firstChar;
206: font->last = fd.f_lastChar;
207: font->base = fd.f_baseline;
208: font->space = fd.f_spaceIndex;
209: font->space += font->first;
210: if (fd.f_fixedWidth) {
211: font->fixed = 1;
212: } else {
213: font->fixed = 0;
214: }
215: font->refcnt = 1;
216: font->name = (char *) Xalloc (strlen (name) + 1);
217: strcpy (font->name, name);
218:
219: /*
220: * Allocate space for the fonts private data structure
221: */
222:
223: fpriv = (FontPriv *) Xalloc (sizeof (FontPriv));
224: font->data = (caddr_t) fpriv;
225:
226: /*
227: * Save pointers to left array, width table , and font bitmap
228: */
229:
230: fpriv->widths = leftarea;
231: fpriv->leftarray = leftarray;
232:
233: /*
234: * Allocate a temporary buffer for the strike bitmap.
235: */
236: if ((strike_bm = (BITMAP *) Xalloc(sizeof(BITMAP))) == NULL) {
237: free (fontarea);
238: free ((caddr_t) leftarea);
239: free ((caddr_t) leftarray);
240: free ((caddr_t) name);
241: free ((caddr_t) font);
242: free ((caddr_t) fpriv);
243: return (NULL);
244: }
245:
246: strike_bm->width = chars->bm_width;
247: strike_bm->height = chars->bm_height;
248: strike_bm->refcnt = 1;
249: strike_bm->data = (caddr_t) fontarea;
250:
251: /*
252: * Convert leftarray to the width table
253: */
254:
255: fpriv->maxwidth = 0;
256: for (i = font->first; i < font->last; i++) {
257: width = fpriv->leftarray[i + 1] - fpriv->leftarray[i];
258: if (width > fpriv->maxwidth) {
259: fpriv->maxwidth = width;
260: }
261: if (width < 0) {
262: width = 0; /* font sanity check */
263: DeviceError ("Bad font leftarray!");
264: } else if (width > 0) {
265: VisibleChars++;
266: }
267: fpriv->widths[i] = width;
268: }
269: fpriv->widths[i] = strike_bm->width - fpriv->leftarray[i];
270: font->avg_width = strike_bm->width / VisibleChars;
271:
272: /*
273: * Make individual bitmaps of each character in font
274: */
275:
276: if (StrikeToBitmaps(font,strike_bm) == NULL) {
277: free (fontarea);
278: free ((caddr_t) leftarea);
279: free ((caddr_t) leftarray);
280: free ((caddr_t) strike_bm);
281: free ((caddr_t) fpriv);
282: free ((caddr_t) name);
283: free ((caddr_t) font);
284: return (NULL);
285: }
286:
287: /*
288: * Set up offscr if the font will fit into the offscreen
289: * buffer.
290: */
291:
292: if (font->height > MAX_OFFSCR_HT) {
293: fpriv->offscr = NILBITMAP;
294: } else {
295: fpriv->offscr = &txtbm;
296: }
297:
298: /*
299: * Don't need the temporary strike bitmap.
300: */
301:
302: free ((caddr_t) strike_bm);
303:
304: /*
305: * Return pointer to FONT stucture
306: */
307:
308: return (font);
309: #undef chars
310: }
311:
312: /*
313: * Free all allocated space used by font
314: */
315:
316: FreeFont (font)
317: register FONT *font;
318: {
319: register FontPriv *data;
320:
321: #ifdef TRACE_X
322: fprintf(stderr, "In FreeFont\n");
323: fflush(stderr);
324: #endif TRACE_X
325:
326: data = FDATA(font);
327: if (data->widths) {
328: free ((caddr_t) data->widths);
329: }
330: FreeBitmap(data->chrs);
331: free ((caddr_t) data);
332: free (font->name);
333: free ((caddr_t) font);
334: }
335:
336: /*
337: * This routine converts strike format into an array of bitmaps
338: */
339:
340: StrikeToBitmaps(font,sbm)
341: FONT *font;
342: BITMAP *sbm;
343: {
344: register FontPriv *fpriv = FDATA(font);
345: register BITMAP *cbm;
346: register charwidth;
347: register charoffset;
348: register i;
349: register desty = 0;
350: int size;
351:
352: #ifdef TRACE_X
353: fprintf(stderr, "In StrikeToBitmaps\n");
354: fflush(stderr);
355: #endif TRACE_X
356:
357: /*
358: * Allocate bitmap structure for character bitmap
359: */
360:
361: if ((cbm = fpriv->chrs = (BITMAP *) Xalloc(sizeof(BITMAP))) == NULL) {
362: return(NULL);
363: }
364:
365: /*
366: * Allocate all of the individual character bitmaps in one shot
367: */
368:
369: cbm->width = (((fpriv->maxwidth + 15) >> 4) << 4);
370: cbm->height = (font->last - font->first + 1) * font->height;
371: size = BitmapSize(cbm->width, cbm->height);
372: cbm->refcnt = 1;
373: if ((cbm->data = (char *) Xalloc(size)) == NULL) {
374: free((caddr_t) cbm);
375: return(NULL);
376: }
377: bzero(cbm->data, size);
378:
379: /*
380: * Loop thru font and blt each character into its
381: * apporpriate bitmap
382: */
383:
384: for (i = font->first; i <= font->last; i++) {
385:
386: charwidth = fpriv->widths[i];
387: charoffset = fpriv->leftarray[i];
388:
389: /*
390: * make source and destination rectangles
391: */
392:
393: FillInRect(charoffset, 0, charwidth, font->height, &SrcRect);
394: FillInRect(0, desty, charwidth, font->height, &DstRect);
395:
396: /*
397: * blt character to bitmap
398: */
399:
400: CopyBits((u_short *)sbm->data,sbm->width,sbm->height, &SrcRect,
401: (u_short *)cbm->data,cbm->width,cbm->height, &DstRect,
402: NILMASK, NIL, NIL, GXcopy, 0, NILCLIP);
403:
404: /*
405: * adjust destination address
406: */
407:
408: desty += font->height;
409: }
410:
411: return(1);
412: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.