![[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 / libis|
Return to font.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libis |
1.1 root 1: /*
2: * $Source: /u1/X/libis/RCS/font.c,v $
3: * $Header: font.c,v 1.1 86/11/17 14:34:11 swick Rel $
4: */
5:
6: #ifndef lint
7: static char *rcsid_font_c = "$Header: font.c,v 1.1 86/11/17 14:34:11 swick Rel $";
8: #endif lint
9:
10: #include "is-copyright.h"
11:
12: /* font.c
13: *
14: * GetFont Takes a font name and stores it
15: * FreeFont Frees the storage taken by a font
16: * MakeFontPixmap Convert font bitmap to pixmap
17: *
18: * Copyright (c) 1986, Integrated Solutions, Inc.
19: */
20:
21: #include "Xis.h"
22: #include "vssite.h"
23: #include <errno.h>
24: #include <sys/file.h>
25:
26: extern int errno;
27:
28: extern char *strcpy();
29: extern char *strcat();
30: extern long lseek();
31: extern PIXMAP *MakePixmap();
32:
33: /*
34: * BitMap and FontData typedefs come from ../libvs100/param.h
35: */
36:
37: /* BitMap typedefs */
38: typedef short a_BitmapEntryPtr[2];
39:
40: typedef struct _Bitmap {
41: a_BitmapEntryPtr bm_address;
42: short bm_width;
43: short bm_height;
44: short bm_bitsPerPixel;
45: } BitMap;
46:
47: typedef short a_Bitmap[5];
48:
49: /* FontData typedefs */
50: typedef short a_FontWidthEntryPtr[2];
51:
52: typedef struct _FontData {
53: a_Bitmap f_characters;
54: short f_firstChar;
55: short f_lastChar;
56: a_FontWidthEntryPtr f_leftArray;
57: short f_baseline;
58: short f_spaceIndex;
59: short f_fixedWidth;
60: } FontData;
61:
62: /*
63: * GetFont
64: */
65: FONT *GetFont(name)
66: char *name;
67: {
68: char pathname[1024]; /* font pathname */
69: int file; /* file descriptor */
70: FontData hdr; /* font file header */
71: #define chars ((BitMap *) hdr.f_characters)
72: int mask_size; /* size of mask bitmap */
73: int xpos_size; /* size of x pos array */
74: char *mask; /* character mask bitmap */
75: register short *xpos; /* x position of characters in mask */
76: register FONT *font; /* font */
77: register FontPriv *fpriv; /* font "private" parts */
78:
79: #ifdef DEBUG
80: if (debug & D_Font)
81: printf("GetFont(name=\"%s\")\n", name);
82: #endif DEBUG
83:
84: /* build pathname */
85: strcpy(pathname, DEFAULT_FONT_DIRECTORY);
86: strcat(pathname, name);
87: strcat(pathname, DEFAULT_FONT_SUFFIX);
88:
89: /* open as "pathname", if open fails try "name" */
90: if ((file = open(pathname, O_RDONLY, 0)) == -1 &&
91: (errno != ENOENT || (file = open(name, O_RDONLY, 0)) == -1)) {
92: errno = EINVAL;
93: return (NULL);
94: }
95:
96: /* read header and swap bytes in shorts */
97: if (read(file, (caddr_t) &hdr, sizeof(FontData)) != sizeof(FontData)) {
98: close(file);
99: errno = EINVAL;
100: return (NULL);
101: }
102: SwapShorts((short *) &hdr, sizeof(FontData));
103:
104: /* read font mask, and swap bits in bytes */
105: mask_size = BitmapSize(chars->bm_width, chars->bm_height);
106: mask = (char *) Xalloc(mask_size);
107: lseek(file, (long) hdr.f_characters[0], 0);
108: if (read(file, mask, mask_size) != mask_size) {
109: close(file);
110: free(mask);
111: errno = EINVAL;
112: return (NULL);
113: }
114: SwapBits((short *) mask, mask_size);
115:
116: /* read x position array */
117: if (hdr.f_fixedWidth == 0) {
118: xpos_size = (hdr.f_lastChar - hdr.f_firstChar + 2) * sizeof(short);
119: xpos = (short *) Xalloc(xpos_size);
120: lseek(file, (long) hdr.f_leftArray[0], 0);
121: if (read(file, (caddr_t) xpos, xpos_size) != xpos_size) {
122: close(file);
123: free(mask);
124: free((caddr_t) xpos);
125: errno = EINVAL;
126: return (NULL);
127: }
128: SwapShorts(xpos, xpos_size);
129: } else {
130: xpos_size = 0;
131: xpos = NULL;
132: }
133:
134: close(file);
135:
136: /* complete "font" struct with info from file */
137: font = (FONT *) Xalloc(sizeof (FONT));
138:
139: font->name = (char *) Xalloc(strlen(name) + 1);
140: strcpy(font->name, name);
141: font->first = hdr.f_firstChar;
142: font->last = hdr.f_lastChar;
143: font->space = hdr.f_spaceIndex;
144: font->space += font->first;
145: font->height = chars->bm_height;
146: if (hdr.f_fixedWidth) {
147: font->avg_width = hdr.f_fixedWidth;
148: font->fixed = 1;
149: } else {
150: font->avg_width = (xpos[font->last] - xpos[font->first]) /
151: (font->last - font->first);
152: font->fixed = 0;
153: }
154: font->base = hdr.f_baseline;
155: font->refcnt = 1;
156: fpriv = (FontPriv *) Xalloc(sizeof(FontPriv));
157: font->data = (caddr_t) fpriv;
158:
159: /* complete "fpriv" struct */
160: {
161: BITMAP *bitmap = (BITMAP *) Xalloc(sizeof(BITMAP));
162: RASTER *raster = (RASTER *) Xalloc(sizeof(RASTER));
163:
164: bitmap->width = chars->bm_width;
165: bitmap->height = chars->bm_height;
166: bitmap->refcnt = 1;
167: bitmap->kind = (char) 0;
168: bitmap->data = (caddr_t) raster;
169:
170: raster->width = (short) ((chars->bm_width+15)>>4)<<1;
171: raster->address = (short *) mask;
172:
173: fpriv->mask = (BITMAP *) bitmap;
174: fpriv->xpos = xpos;
175:
176: /* if x position array exists use it to create width array */
177: if (xpos) {
178: register short *p, *limitp;
179:
180: fpriv->widths = (short *) Xalloc (xpos_size);
181:
182: bcopy((char *)xpos, fpriv->widths, xpos_size);
183:
184: limitp = &fpriv->widths[font->last];
185: for (p = &fpriv->widths[font->first]; p <= limitp; ++p) {
186: *p = p[1] - *p;
187: }
188: } else {
189: fpriv->widths = NULL;
190: }
191: }
192:
193: /* initialize font_pixmaps */
194: {
195: register int i;
196: for (i=0; i<FONTPIXMAPS; ++i) {
197: fpriv->font_pixmaps[i].p = NULL;
198: }
199: fpriv->next_pixmap = 0;
200: }
201:
202: return (font);
203: #undef chars
204: }
205:
206: /*
207: * FreeFont
208: */
209: FreeFont(font)
210: register FONT *font;
211: {
212: register FontPriv *fpriv = FDATA(font);
213: BITMAP *bitmap = (BITMAP *)fpriv->mask;
214: register RASTER *raster = (RASTER *)bitmap->data;
215:
216: #ifdef DEBUG
217: if (debug & D_Font)
218: printf("FreeFont(font=0x%x)\n", font);
219: #endif DEBUG
220:
221: /* free text bitmap */
222: free((caddr_t) raster->address);
223: free((caddr_t) raster);
224: free((caddr_t) bitmap);
225:
226: /* free xpos and widths arrays */
227: if (fpriv->xpos) {
228: free((caddr_t) fpriv->xpos);
229: free((caddr_t) fpriv->widths);
230: }
231:
232: /* free font pixmaps */
233: {
234: register int i;
235: register struct _font_pixmaps *font_pixmaps = &fpriv->font_pixmaps[0];
236: for (i = 0; i < FONTPIXMAPS; ++i, ++font_pixmaps) {
237: if (font_pixmaps->p) {
238: FreePixmap(font_pixmaps->p);
239: }
240: }
241: }
242:
243: /* free remainder of font data */
244: free((caddr_t) fpriv);
245: free(font->name);
246: free((caddr_t) font);
247: }
248:
249: /*
250: * MakeFontPixmap
251: */
252: PIXMAP *MakeFontPixmap(font, fore, back)
253: FONT *font;
254: register int fore, back;
255: {
256: register FontPriv *fdata = FDATA(font);
257: register struct _font_pixmaps *font_pixmap = &fdata->font_pixmaps[0];
258: register int i;
259:
260: #ifdef DEBUG
261: if (debug & D_FontPixmap)
262: printf("MakeFontPixmap(font=0x%x, fore=%d, back=%d)\n", font, fore, back);
263: #endif DEBUG
264:
265: /* search font_pixmaps for match */
266: for (i = 0; i < FONTPIXMAPS; ++i) {
267: if (font_pixmap->p &&
268: font_pixmap->fore == fore && font_pixmap->back == back) {
269: /* found match */
270: return (font_pixmap->p);
271: }
272: }
273:
274: /* free entry if necessary */
275: font_pixmap = &fdata->font_pixmaps[fdata->next_pixmap];
276: if (font_pixmap->p != NULL) {
277: FreePixmap(font_pixmap->p);
278: }
279:
280: /* create pixmap and save in font_pixmaps */
281: font_pixmap->fore = fore;
282: font_pixmap->back = back;
283: font_pixmap->p = MakePixmap(fdata->mask, fore, back);
284: fdata->next_pixmap = (fdata->next_pixmap + 1) % FONTPIXMAPS;
285:
286: return (font_pixmap->p);
287: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.