![[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] / 43BSD / contrib / X / libvs100|
Return to font.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / libvs100 |
1.1 root 1: /* $Header: font.c,v 10.3 86/02/01 15:46:53 tony Rel $ */
2: /* font.c Reads a font from a file and stores it on the workstation
3: *
4: * GetFont Takes a font name and stores it
5: * FreeFont Frees the storage taken by a font
6: *
7: */
8:
9: /****************************************************************************
10: * *
11: * Copyright (c) 1983, 1984 by *
12: * DIGITAL EQUIPMENT CORPORATION, Maynard, Massachusetts. *
13: * All rights reserved. *
14: * *
15: * This software is furnished on an as-is basis and may be used and copied *
16: * only with inclusion of the above copyright notice. This software or any *
17: * other copies thereof may be provided or otherwise made available to *
18: * others only for non-commercial purposes. No title to or ownership of *
19: * the software is hereby transferred. *
20: * *
21: * The information in this software is subject to change without notice *
22: * and should not be construed as a commitment by DIGITAL EQUIPMENT *
23: * CORPORATION. *
24: * *
25: * DIGITAL assumes no responsibility for the use or reliability of its *
26: * software on equipment which is not supplied by DIGITAL. *
27: * *
28: * *
29: ****************************************************************************/
30:
31: #include "vs100.h"
32: #include "vssite.h"
33: #include <errno.h>
34:
35: extern int errno;
36:
37: char *Xalloc(), *AllocateSpace(), *strcpy(), *strcat();
38: long lseek();
39: VSArea *VSAlloc();
40:
41: FONT *GetFont (name)
42: char *name;
43: {
44: char fontname[256];
45: int fontfile;
46: FontData font;
47: register FontData *fontCopy;
48: #define chars ((BitMap *) font.f_characters)
49: int fontsize, leftsize, width;
50: char *fontarea;
51: register short *leftarea;
52: register FONT *fd;
53: FontPriv *fpriv;
54: register BitMap *mychars;
55:
56: strcpy (fontname, DEFAULT_FONT_DIRECTORY);
57: strcat (fontname, name);
58: strcat (fontname, DEFAULT_FONT_SUFFIX);
59:
60: if ((fontfile = open (fontname, 0)) == -1 &&
61: (errno != ENOENT || (fontfile = open (name, 0)) == -1)) {
62: errno = EINVAL;
63: return (NULL);
64: }
65:
66: if (read (fontfile, (caddr_t) &font, sizeof (FontData)) != sizeof (FontData)) {
67: close (fontfile);
68: errno = EINVAL;
69: return (NULL);
70: }
71:
72: fontsize = BitmapSize(chars->bm_width, chars->bm_height);
73: fontarea = (char *) Xalloc (fontsize);
74: lseek (fontfile, (long) font.f_characters[0], 0);
75: if (read (fontfile, fontarea, fontsize) != fontsize) {
76: close (fontfile);
77: free (fontarea);
78: errno = EINVAL;
79: return (NULL);
80: }
81:
82: if (font.f_fixedWidth == 0) {
83: leftsize = (font.f_lastChar - font.f_firstChar + 2) * sizeof (short);
84: leftarea = (short *) Xalloc (leftsize);
85: lseek (fontfile, (long) font.f_leftArray[0], 0);
86: if (read (fontfile, (caddr_t) leftarea, leftsize) != leftsize) {
87: close (fontfile);
88: free (fontarea);
89: free ((caddr_t) leftarea);
90: errno = EINVAL;
91: return (NULL);
92: }
93: } else {
94: leftsize = 0;
95: leftarea = NULL;
96: }
97:
98: close (fontfile);
99:
100: if ((fontCopy = (FontData *)
101: AllocateSpace (sizeof (FontData))) == NULL) {
102: free (fontarea);
103: if (leftarea)
104: free ((caddr_t) leftarea);
105: errno = ENOMEM;
106: return (NULL);
107: }
108: mychars = (BitMap *) fontCopy->f_characters;
109: fd = (FONT *) Xalloc (sizeof (FONT));
110:
111: mychars->bm_address[0] = sizeof (FontData);
112: mychars->bm_address[1] = 0;
113: mychars->bm_width = chars->bm_width;
114: fd->height = mychars->bm_height = chars->bm_height;
115: mychars->bm_bitsPerPixel = 1;
116: fd->first = fontCopy->f_firstChar = font.f_firstChar;
117: fd->last = fontCopy->f_lastChar = font.f_lastChar;
118: if (leftarea)
119: fontCopy->f_leftArray[0] = sizeof (FontData) + fontsize;
120: else
121: fontCopy->f_leftArray[0] = 0;
122: fontCopy->f_leftArray[1] = 0;
123:
124: fd->base = fontCopy->f_baseline = font.f_baseline;
125: fd->space = fontCopy->f_spaceIndex = font.f_spaceIndex;
126: fd->space += fd->first;
127: if (fd->avg_width = fontCopy->f_fixedWidth = font.f_fixedWidth)
128: fd->fixed = 1;
129: else
130: fd->fixed = 0;
131:
132: fd->refcnt = 1;
133: fpriv = (FontPriv *) Xalloc (sizeof (FontPriv));
134: fd->data = (caddr_t) fpriv;
135: fpriv->widths = leftarea;
136:
137: if ((fpriv->remote = (VSArea *) VSAlloc (sizeof (FontData) + fontsize + leftsize,
138: FONT_TYPE)) == NULL) {
139: free (fontarea);
140: if (leftarea)
141: free ((caddr_t) leftarea);
142: free ((caddr_t) fd);
143: free ((caddr_t) fpriv);
144: return (NULL);
145: }
146: fd->name = (char *) Xalloc (strlen (name) + 1);
147: strcpy (fd->name, name);
148:
149: if (MoveObjectDown ((caddr_t) fontCopy, fpriv->remote->vsPtr, sizeof (FontData)) ||
150: MoveBufferDown (fontarea,
151: fpriv->remote->vsPtr + sizeof (FontData),
152: fontsize) ||
153: (leftarea &&
154: MoveBufferDown ((caddr_t) leftarea,
155: fpriv->remote->vsPtr + sizeof (FontData) + fontsize,
156: leftsize))) {
157: free (fontarea);
158: FreeFont (fd);
159: errno = ENOMEM;
160: return (NULL);
161: }
162:
163: if (leftarea) {
164: leftsize = font.f_lastChar - font.f_firstChar + 1;
165: width = 0;
166: fontsize = 0;
167: while (--leftsize >= 0) {
168: *leftarea = leftarea[1] - *leftarea;
169: if (*leftarea) {
170: width += *leftarea;
171: fontsize++;
172: }
173: leftarea++;
174: }
175: fd->avg_width = width / fontsize;
176: }
177: free (fontarea);
178: return (fd);
179: #undef chars
180: }
181:
182: FreeFont (font)
183: register FONT *font;
184: {
185: register FontPriv *data;
186:
187: data = FDATA(font);
188: if (data->widths) free ((caddr_t) data->widths);
189: VSFree (data->remote);
190: free ((caddr_t) data);
191: free (font->name);
192: free ((caddr_t) font);
193: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.