4.3BSD/usr/src/old/fed/io.c
#ifndef lint
static char sccsid[] = "@(#)io.c 4.2 (Berkeley) 8/11/83";
#endif
/*
* io.c: font file I/O subroutines for fed.
*/
#include "fed.h"
getglyph(c)
char c;
{
register int i, j;
int windno;
int vertoff, horoff;
char *tmp;
if (trace)
fprintf(trace, "\n\ngetglyph(%s)\n", rdchar(c));
if (disptable[c].nbytes == 0) {
if (trace)
fprintf(trace, "no such char: %s\n", rdchar(c));
sprintf(msgbuf, "no such character: %s", rdchar(c));
message(msgbuf);
return;
}
curchar = c;
turnofcurs();
if (cht[curchar].wherewind >= 0) {
/* It's already in a window. Don't have to do much. */
if (trace)
fprintf(trace, "already in %d\n", cht[curchar].wherewind);
windno = cht[curchar].wherewind;
/* Put a box around the current window */
if (windno != curwind) {
drawbox(base[curwind].r-1, base[curwind].c-1, 0, GLROW+2, GLCOL+2);
drawbox(base[windno].r-1, base[windno].c-1, 1, GLROW+2, GLCOL+2);
}
curwind = windno;
syncwind(windno);
/* should center base */
} else {
/*
* Not on screen. First find a suitable window,
* using round robin.
*/
windno = nextwind;
if (trace)
fprintf(trace, "chose window %d\n", windno);
if (++nextwind >= NWIND)
nextwind = 0;
#ifdef TWOWIND
/*
* This is for debugging what happens when we run out
* of windows.
*/
if (nextwind >= 2)
nextwind = 0;
#endif
/* Put a box around the current window */
if (windno != curwind) {
if (trace)
fprintf(trace, "drawbox (%d %d)\n", base[windno].r-1, base[windno].c-1);
drawbox(base[curwind].r-1, base[curwind].c-1, 0, GLROW+2, GLCOL+2);
drawbox(base[windno].r-1, base[windno].c-1, 1, GLROW+2, GLCOL+2);
}
/* Print the char at the lower left of the window */
sprintf(msgbuf, "%s", rdchar(curchar));
dispmsg(msgbuf, base[windno].c, base[windno].r-11, 2);
/* Now make room in the window */
if (wind[windno].onscreen == NULL) {
/* Brand new window, have to allocate space */
wind[windno].onscreen = newmat(GLROW, GLCOL);
} else {
/* Save prev glyph for later */
cht[wind[windno].used].whereat = wind[windno].val;
cht[wind[windno].used].wherewind = -2;
if (trace)
fprintf(trace, "windno=%s, wind[windno].used=%d, cht[..].wherewind set to -2\n", rdchar(windno), wind[windno].used);
}
if (wind[windno].undval != NULL) {
if (trace)
fprintf(trace, "getglyph frees undo: %x\n", wind[windno].undval);
free(wind[windno].undval);
}
wind[windno].undval = NULL;
wind[windno].used = curchar;
/*
* Vertical & horizontal offsets. Line up the baseline
* of the char at BASELINE from bottom, but center
* horizontally.
*/
vertoff = GLROW - BASELINE - disptable[curchar].up;
/* Check to see if the glyph is being nosed off the edge. */
if (vertoff < 0) {
vertoff = 0;
} else if (vertoff + disptable[curchar].up + disptable[curchar].down >= GLROW) {
vertoff = GLROW - disptable[curchar].up - disptable[curchar].down;
}
horoff = (GLCOL-(disptable[curchar].left+disptable[curchar].right)) / 2;
wind[windno].val = findbits(curchar, GLROW, GLCOL, horoff, vertoff, &curs_r, &curs_c);
cht[curchar].rcent = curs_r;
cht[curchar].ccent = curs_c;
curwind = windno;
cht[curchar].wherewind = windno;
syncwind(windno);
}
}
/*
* writeback: write the font back to the file at the end of editing.
* Also have to write width table.
*/
writeback()
{
writefont(fontfile);
}
/*
* writefont: write current font on file fname.
*/
writefont(fname)
char *fname;
{
register int i, j;
register int c;
FILE *fntout;
int bytes;
bitmat tmp;
int nextoff = 0;
int charcount, bytecount;
extern char *sys_errlist[];
extern int errno;
if (trace)
fprintf(trace, "writefont(%s)\n", fname);
/*
* The following unlink is important because we are about to
* do an fopen( , "w") on fname. We still have fontdes open
* for reading. If we don't do the unlink the fopen will truncate
* the file and subsequent reads will fail. If we do the unlink
* the file won't go away until it is closed, so we can still
* read from the old version.
*/
if (strcmp(fname, fontfile)==0 && unlink(fname) < 0) {
sprintf(msgbuf, "unlink %s: %s", fname, sys_errlist[errno]);
error(msgbuf);
}
fntout = fopen(fname, "w");
if (fntout == NULL) {
sprintf(msgbuf, "%s: %s", fname, sys_errlist[errno]);
if (trace)
fprintf(trace, "%s\n", msgbuf);
error(msgbuf);
}
sprintf(msgbuf, "\"%s\"", fname);
message(msgbuf);
fflush(stdout);
fwrite(&FontHeader, sizeof FontHeader, 1, fntout);
fwrite(&disptable[0], sizeof disptable, 1, fntout);
charcount = 0; bytecount = fbase;
for (c=0; c<256; c++)
if (disptable[c].nbytes || cht[c].wherewind != -1) {
if (trace)
fprintf(trace, "char %s, nbytes %d, wherewind %d.. ", rdchar(c), disptable[c].nbytes, cht[c].wherewind);
packmat(c, &tmp, &bytes);
disptable[c].addr = nextoff;
disptable[c].nbytes = bytes;
if (trace)
fprintf(trace, "offset %d size %d\n", nextoff, bytes);
nextoff += bytes;
fwrite(tmp, bytes, 1, fntout);
charcount++;
bytecount += bytes;
}
FontHeader.size = nextoff;
fseek(fntout, 0L, 0);
fwrite(&FontHeader, sizeof FontHeader, 1, fntout);
fwrite(&disptable[0], sizeof disptable, 1, fntout);
/* Should fix the width tables here */
fclose(fntout);
sprintf(msgbuf, "%s %d glyphs, %d bytes", fname, charcount, bytecount);
message(msgbuf);
changes = 0;
}
/*
* make a packed matrix of the bits for char c.
* return the matrix ptr in result and the size in bytes in nbytes.
*/
packmat(c, result, nbytes)
int c;
bitmat *result;
int *nbytes;
{
register int i, j;
bitmat wp;
int nb, nr, nc;
int rmin, cmin, rmax, cmax;
static char tmp[WINDSIZE];
if (cht[c].wherewind == -1) {
/* It has never been read from file. Just copy from file. */
nb = disptable[c].nbytes;
fseek(fontdes, (long) fbase+disptable[c].addr, 0);
fread(tmp, nb, 1, fontdes);
} else {
if (cht[c].wherewind == -2)
wp = cht[c].whereat;
else
wp = wind[cht[c].wherewind].val;
minmax(wp, GLROW, GLCOL, &rmin, &cmin, &rmax, &cmax);
nr = rmax-rmin+1; nc = cmax-cmin+1;
zermat(tmp, nr, nc);
for (i=rmin; i<=rmax; i++)
for (j=cmin; j<=cmax; j++) {
setmat(tmp, nr, nc, i-rmin, j-cmin,
mat(wp, GLROW, GLCOL, i, j));
}
nb = ((nc + 7) >> 3) * nr;
disptable[c].up = cht[c].rcent - rmin;
disptable[c].down = rmax - cht[c].rcent + 1;
disptable[c].left = cht[c].ccent - cmin;
disptable[c].right = cmax - cht[c].ccent + 1;
if (trace) {
fprintf(trace, "rmax=%d, rcent=%d, rmin=%d, cmax=%d, ccent=%d, cmin=%d, ", rmax, cht[c].rcent, rmin, cmax, cht[c].ccent, cmin);
fprintf(trace, "up=%d, down=%d, left=%d, right=%d\n", disptable[c].up, disptable[c].down, disptable[c].left, disptable[c].right);
}
}
*result = tmp;
*nbytes = nb;
if (trace)
fprintf(trace, "nbytes = %d, ", nb);
return;
}
/*
* editfont: make the file fname be the current focus of attention,
* including reading it into the buffer.
*/
editfont(fname)
char *fname;
{
register char *cp;
clearfont();
editing = 1;
truename(fname, fontfile);
fontdes = fopen(fontfile, "r");
readfont(fontfile, 0, 255);
/*
* Figure out the point size, and make a guess as to the
* appropriate width of the heavy pen.
*/
for (cp=fontfile; *cp && *cp!='.'; cp++)
;
if (*cp) {
pointsize = atoi(++cp);
setpen(pointsize>30?3 : pointsize>15?2 : pointsize>8?1 : 0);
} else {
pointsize = 0;
setpen(2);
}
}
/*
* readfont: read in a font, overlaying the current font.
* also used to edit a font by clearing first.
*
* Conflicts are handled interactively.
*/
readfont(fname, c1, c2)
char *fname;
int c1, c2;
{
register int i;
register char *cp;
struct dispatch d;
char choice, mode = 0;
FILE *hold_fontdes;
int horoff, vertoff;
long ftsave;
hold_fontdes = fontdes;
fontdes = fopen(fname, "r");
if (fontdes == NULL) {
sprintf(msgbuf, "%s not found", fname);
fontdes = hold_fontdes;
error(msgbuf);
}
fread(&FontHeader, sizeof FontHeader, 1, fontdes);
fseek(fontdes, c1*sizeof d, 1); /* skip over unread chars */
ftsave = ftell(fontdes);
for (i=c1; i<=c2; i++) {
fseek(fontdes, ftsave, 0);
fread(&d, sizeof d, 1, fontdes);
ftsave = ftell(fontdes);
/* Decide which of the two to take */
if (d.nbytes == 0)
continue; /* We take the one in the buffer */
if (disptable[i].nbytes > 0) {
/* Conflict */
switch(mode) {
case 'f':
/* fall through */
break;
case 'b':
continue;
default:
sprintf(msgbuf, "%s <file> or <buffer>", rdchar(i));
message(msgbuf);
choice = inchar();
switch(choice) {
case 'F':
mode = 'f';
default:
case 'f':
break;
case 'B':
mode = 'b';
case 'b':
continue;
}
}
}
disptable[i] = d; /* We take the one in the file */
cht[i].nrow = d.up + d.down;
cht[i].ncol = d.left + d.right;
if (!editing && disptable[i].nbytes) {
horoff = (GLCOL-(disptable[i].left+disptable[i].right))/2;
vertoff = GLROW - BASELINE - disptable[i].up;
/* Check to see if the glyph is being nosed off the edge. */
if (vertoff < 0) {
vertoff = 0;
} else if (vertoff + disptable[curchar].up + disptable[curchar].down >= GLROW) {
vertoff = GLROW - disptable[curchar].up - disptable[curchar].down;
}
if (cht[i].wherewind >= 0) {
/* The old glyph is in a window - destroy it */
wind[cht[i].wherewind].used = -1;
}
cht[i].wherewind = -1;
cht[i].whereat = findbits(i, GLROW, GLCOL, horoff, vertoff, &cht[i].rcent, &cht[i].ccent);
cht[i].wherewind = -2;
if (trace)
fprintf(trace, "setting cht[%d].wherewind to -2 in readfont\n", i);
} else
cht[i].wherewind = -1;
}
fbase = sizeof FontHeader + sizeof disptable; /* ftell(fontdes) */
sprintf(msgbuf, "\"%s\", raster data %d bytes, width %d, height %d, xtend %d", fname, FontHeader.size, FontHeader.maxx, FontHeader.maxy, FontHeader.xtend);
fontdes = hold_fontdes;
message(msgbuf);
}
/*
* Figure out the true name of the font file, given that
* the abbreviated name is fname. The result is placed
* in the provided buffer result.
*/
truename(fname, result)
char *fname;
char *result;
{
FILE *t;
strcpy(result, fname);
if ((t = fopen(result, "r")) == NULL) {
sprintf(result,"/usr/lib/vfont/%s",fname);
if ((t = fopen(result, "r")) == NULL) {
strcpy(result, fname);
sprintf(msgbuf, "Can't find %s\n",fname);
error(msgbuf);
}
}
fclose(t);
}
/*
* clearfont: delete all characters in the current font.
*/
clearfont()
{
register int i;
if (fontdes)
fclose(fontdes);
for (i=0; i<256; i++) {
cht[i].wherewind = -1;
disptable[i].addr = 0;
disptable[i].nbytes = 0;
disptable[i].up = 0;
disptable[i].down = 0;
disptable[i].left = 0;
disptable[i].right = 0;
disptable[i].width = 0;
}
}
/*
* fileiocmd: do a file I/O command. These all take optional file
* names, defaulting to the current file.
*/
fileiocmd(cmd)
char cmd;
{
char fname[100], truefname[100];
readline("file: ", fname, sizeof fname);
if (fname[0] == 0 || fname[0] == ' ')
strcpy(fname, fontfile);
switch(cmd) {
case 'E':
confirm();
editfont(fname);
break;
case 'N':
if (changes)
writeback();
editfont(fname);
break;
case 'R':
editing = 0;
truename(fname, truefname);
readfont(truefname, 0, 255);
changes++;
break;
case 'W':
editing = 0;
writefont(fname);
break;
}
if (editing)
changes = 0;
}
/*
* readchars: read in a partial font (the P command).
*/
readchars()
{
int c1, c2;
char fnamebuf[100];
char truebuf[100];
char buf[5];
message("Partial read <firstchar>");
c1 = inchar();
sprintf(msgbuf, "Partial read %s thru <lastchar>", rdchar(c1));
message(msgbuf);
c2 = inchar();
strcpy(buf, rdchar(c1));
sprintf(msgbuf, "Partial read %s thru %s from file: ", buf, rdchar(c2));
readline(msgbuf, fnamebuf, sizeof fnamebuf);
editing = 0;
if (fnamebuf[0] == 0 || fnamebuf[0] == ' ')
strcpy(fnamebuf, fontfile);
truename(fnamebuf, truebuf);
changes++;
readfont(truebuf, c1, c2);
}