![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / old / fed|
Return to subr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / old / fed |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)subr.c 4.2 (Berkeley) 8/11/83";
3: #endif
4:
5: /*
6: * subr.c: general subroutines for fed.
7: */
8:
9: #include "fed.h"
10:
11: /*
12: * initialize: various one time initializations.
13: */
14: initialize()
15: {
16: register int i, j;
17: register char *cp;
18:
19: /* Initialize random variables */
20: curwind = -1;
21: pencolor = 1;
22: penweight = 0;
23:
24: /*
25: * Initialize value of sqrtmat. This is a constant table
26: * so we don't have to redo all these square roots when the pen
27: * changes every time.
28: */
29: for (i=0; i<10; i++) {
30: for (j=0; j<10; j++) {
31: sqrtmat[i][j] = sqrt((float) i*i + j*j);
32: }
33: }
34:
35: /* Initialize base locations on screen. These remain fixed. */
36: for (i=0; i<NROW; i++)
37: for (j=0; j<NCOL; j++) {
38: base[NCOL*i+j].c = (GLCOL+GLPAD) * j + 1;
39: base[NCOL*i+j].r = SCRHI - (GLROW+GLPAD+10) * i - GLROW - 3;
40: }
41:
42: setbuf(stdout, stoutbuf);
43:
44: curzoom = 1; /* default is zoomed completely out */
45: ttyinit();
46: }
47:
48: /*
49: * showfont: Wipe clean the screen, display the font
50: * in a properly spaced fashion, wait for a char to be typed, if it's
51: * p print the font, then clear the screen and ungetc the char.
52: */
53: showfont()
54: {
55: register int i, cr, cc, nc;
56: int roff, coff;
57: char maxc, minc;
58: char nextcmd;
59: char tmpbuf[WINDSIZE];
60:
61: zoomout();
62: message("Show font from <char>");
63: minc = inchar();
64: sprintf(msgbuf, "Show font from %s to <char>", rdchar(minc));
65: message(msgbuf);
66: maxc = inchar();
67:
68: clearg();
69: zermat(tmpbuf, GLROW, GLCOL);
70: cr = SCRHI-GLROW; cc = 3;
71: for (i=minc; i<=maxc; i++) {
72: if (disptable[i].nbytes) {
73: /*
74: * We really should try to find out how far to the
75: * left the glyph goes so we don't run off the left
76: * end of the screen, but this is hard, so we fake it.
77: * Usually glyphs don't run past the left so it's OK.
78: */
79: if (cc - disptable[i].left < 0)
80: cc = disptable[i].left;
81: nc = cc + disptable[i].width;
82: if (nc >= SCRWID) {
83: cc = 0;
84: nc = disptable[i].width;
85: cr -= 85; /* Should be GLROW but 4*100>360 */
86: if (cr < 0)
87: break; /* Screen full. Just stop. */
88: }
89: dispmsg(rdchar(i), cc, cr, 2);
90: placechar(i, cr+BASELINE, cc, tmpbuf);
91: cc = nc;
92: }
93: }
94: for (;;) {
95: nextcmd = inchar();
96: if (nextcmd != 'p')
97: break;
98: printg();
99: }
100: if (nextcmd != 'Q' && nextcmd != 'E' && nextcmd != 'N')
101: redraw();
102: else
103: clearg();
104: ungetc(nextcmd, stdin);
105: }
106:
107: /*
108: * typein: Like showfont but takes a line of text from the user
109: * and "typesets" it on the screen.
110: */
111: typein()
112: {
113: register int i, cr, cc, nc;
114: char *p;
115: int roff, coff;
116: char maxc, minc;
117: char nextcmd;
118: char tmpbuf[WINDSIZE];
119: char msgtype[100];
120:
121: zoomout();
122: readline("Input line to be typeset: ", msgtype, sizeof msgtype);
123:
124: clearg();
125: zermat(tmpbuf, GLROW, GLCOL);
126: cr = SCRHI-GLROW; cc = 3;
127: for (p=msgtype; *p; p++) {
128: i = *p;
129: if (disptable[i].nbytes) {
130: if (cc - disptable[i].left < 0)
131: cc = disptable[i].left;
132: nc = cc + disptable[i].width;
133: if (nc >= SCRWID) {
134: cc = 0;
135: nc = disptable[i].width;
136: cr -= 85; /* Should be GLROW but 4*100>360 */
137: if (cr < 0)
138: break; /* Screen full. Just stop. */
139: }
140: dispmsg(rdchar(i), cc, cr, 2);
141: placechar(i, cr+BASELINE, cc, tmpbuf);
142: cc = nc;
143: }
144: }
145: for (;;) {
146: nextcmd = inchar();
147: if (nextcmd != 'p')
148: break;
149: printg();
150: }
151: if (nextcmd != 'Q' && nextcmd != 'E' && nextcmd != 'N')
152: redraw();
153: else
154: clearg();
155: ungetc(nextcmd, stdin);
156: }
157:
158: /*
159: * placechar: draw the character ch at position (llr, llc) on the screen.
160: * Position means the logical center of the character. zero is a GLROW x GLCOL
161: * matrix of zeros which is needed for comparison, that is, we assume that
162: * the spot on the screen where this is going is blank, so the chars better
163: * not overlap.
164: */
165: placechar(ch, llr, llc, zero)
166: int ch;
167: int llr, llc;
168: bitmat zero;
169: {
170: bitmat glbuf;
171: int roff, coff;
172:
173: glbuf = findbits(ch, GLROW, GLCOL, 0, 0, &roff, &coff);
174: if (glbuf == NULL)
175: return;
176: if (trace)
177: fprintf(trace, "placechar('%s'), roff=%d, coff=%d, llr=%d, llc=%d, down=%d, left=%d, r=%d, c=%d\n", rdchar(ch), roff, coff, llr, llc, disptable[ch].down, disptable[ch].left, llr-disptable[ch].down, llc-disptable[ch].left);
178:
179: update(zero, glbuf, GLROW, GLCOL, llr-GLROW+roff, llc-coff);
180: if (trace)
181: fprintf(trace, "placechar, free %x\n", glbuf);
182: free(glbuf);
183: }
184:
185: /*
186: * redraw: The screen has gotten screwed up somehow.
187: * Assume nothing but make it look right.
188: */
189: redraw()
190: {
191: register int i;
192:
193: zoomout();
194: clearg();
195: turnofrb();
196: for (i=0; i<NWIND; i++)
197: if (wind[i].onscreen != NULL) {
198: zermat(wind[i].onscreen, GLROW, GLCOL);
199: syncwind(i);
200:
201: /* Print the char at the lower left of the window */
202: sprintf(msgbuf, "%s", rdchar(wind[i].used));
203: dispmsg(msgbuf, base[i].c, base[i].r-11, 2);
204: }
205: if (curwind >= 0)
206: drawbox(base[curwind].r-1, base[curwind].c-1, 1, GLROW+2, GLCOL+2);
207: }
208:
209: /*
210: * findbits: find the data bits of glyph c, wherever they are, and make
211: * nr x nc bitmat and put them in it, shifted by horoff and vertoff.
212: */
213: bitmat
214: findbits(c, nr, nc, horoff, vertoff, rcenter, ccenter)
215: int c;
216: int nr, nc; /* the size of the dest */
217: int horoff, vertoff;
218: int *rcenter, *ccenter;
219: {
220: register int i, j;
221: register int r1, r2, c1, c2;
222: bitmat retval, source;
223: int tr, tc; /* the size of source */
224: char tmp[WINDSIZE];
225:
226: if (trace)
227: fprintf(trace, "findbits(c=%s, nr=%d, nc=%d, horoff=%d, vertoff=%d\n", rdchar(c), nr, nc, horoff, vertoff);
228: if (disptable[c].nbytes == 0)
229: return (NULL);
230: switch (cht[c].wherewind) {
231: case -2:
232: if (trace)
233: fprintf(trace, "case -2, saved from prev place\n");
234: /* Saved from previous place */
235: source = cht[c].whereat;
236:
237: /* Ignore horoff/vertoff assuming they are already right */
238: *rcenter = cht[c].rcent;
239: *ccenter = cht[c].ccent;
240: /*
241: * Small but important optimization: if the desired result is
242: * a whole window and the source happens to be in a whole
243: * window, just return the source pointer. This saves
244: * lots of memory copies and happens quite often.
245: */
246: if (nr == GLROW && nc == GLCOL)
247: return (source);
248: tr = GLROW; tc = GLCOL;
249: break;
250: case -1:
251: if (trace)
252: fprintf(trace, "case -1: first time\n");
253: /* First time for this glyph: get it from font file */
254: fseek(fontdes, (long) fbase+disptable[c].addr, 0);
255: tr = cht[c].nrow; tc = cht[c].ncol;
256: if (tr > GLROW || tc > GLCOL || disptable[c].nbytes > WINDSIZE)
257: error("glyph too large for window");
258: *rcenter = vertoff + disptable[c].up;
259: *ccenter = horoff + disptable[c].left;
260: source = tmp;
261: fread(source, disptable[c].nbytes, 1, fontdes);
262: break;
263: default:
264: if (trace)
265: fprintf(trace, "case default, in window %d", cht[c].wherewind);
266: source = wind[cht[c].wherewind].val;
267: tr = GLROW; tc = GLCOL;
268: *rcenter = vertoff + cht[c].rcent;
269: *ccenter = horoff + cht[c].ccent;
270: break;
271: }
272: if (trace)
273: fprintf(trace, "curchar=%c=%d, tr=%d, tc=%d\n", curchar, curchar, tr, tc);
274:
275: dumpmat("before copy, source", source, tr, tc);
276: /* Copy in the bits into a bitmat of the right size */
277: retval = newmat(nr, nc);
278: r1 = max(0, -vertoff);
279: r2 = min(GLROW-vertoff-1, GLROW-1);
280: r2 = min(r2, tr-1);
281: c1 = max(0, -horoff);
282: c2 = min(GLCOL-horoff-1, GLCOL-1);
283: c2 = min(c2, tc-1);
284: if (trace)
285: fprintf(trace, "findbits copy: r1=%d, r2=%d, c1=%d, c2=%d, horoff=%d, vertoff=%d\n", r1, r2, c1, c2, horoff, vertoff);
286: for (i=r1; i<=r2; i++) {
287: for (j=c1; j<=c2; j++)
288: setmat(retval, nr, nc, i+vertoff, j+horoff, mat(source, tr, tc, i, j, 6));
289: }
290: dumpmat("result of copy", retval, nr, nc);
291: return (retval);
292: }
293:
294: /*
295: * bufmod: called just before a buffer modifying command.
296: * Makes a backup copy of the glyph so we can undo later.
297: */
298: bufmod()
299: {
300: changes++;
301: if (curwind < 0)
302: return;
303: if (wind[curwind].undval == NULL)
304: wind[curwind].undval = newmat(GLROW, GLCOL);
305: bitcopy(wind[curwind].undval, wind[curwind].val, GLROW, GLCOL);
306: und_p_r = pen_r; und_p_c = pen_c;
307: und_c_r = curs_r; und_c_c = curs_c;
308: }
309:
310: /*
311: * undo: restore the backup copy. We just swap pointers, which is
312: * the same as interchanging the two matrices. This way, undo is
313: * its own inverse.
314: */
315: undo()
316: {
317: register bitmat tmp;
318:
319: if (wind[curwind].undval == NULL) {
320: error("Nothing to undo");
321: }
322: tmp = wind[curwind].val;
323: wind[curwind].val = wind[curwind].undval;
324: wind[curwind].undval = tmp;
325: pen_r = und_p_r; pen_c = und_p_c;
326: move(base[curwind].c+pen_c, base[curwind].r+GLROW-pen_r);
327: curs_r = und_c_r; curs_c = und_c_c;
328: syncwind(curwind);
329: changes++;
330: }
331:
332: /*
333: * drawline: draw a line of current flavor between the named two points.
334: * All points are relative to current window.
335: *
336: * The algorithm is that of a simple DDA. This is similar to what the
337: * hardware of the HP 2648 does but the placing of the points will be
338: * different (because of thick pens and erasers).
339: */
340: drawline(from_r, from_c, to_r, to_c)
341: {
342: int length, i;
343: float x, y, xinc, yinc;
344:
345: if (trace)
346: fprintf(trace, "drawline from (%d, %d) to (%d, %d)\n", from_r, from_c, to_r, to_c);
347: length = max(abs(to_r-from_r), abs(to_c-from_c));
348: if (length <= 0) {
349: /*
350: * The actual value doesn't matter, we're just avoiding
351: * division by zero here.
352: */
353: xinc = yinc = 1.0;
354: } else {
355: xinc = ((float) (to_r-from_r))/length;
356: yinc = ((float) (to_c-from_c))/length;
357: }
358: drawpoint(from_r, from_c);
359: x = from_r + 0.5; y = from_c + 0.5;
360:
361: for (i=0; i<length; i++) {
362: x += xinc; y += yinc;
363: drawpoint((int) x, (int) y);
364: }
365: }
366:
367: /*
368: * drawpoint: make a point of the current flavor at (r, c).
369: */
370: drawpoint(r, c)
371: register int r, c;
372: {
373: register int i, j;
374:
375: if (penweight == 0)
376: setmat(wind[curwind].val, GLROW, GLCOL, r, c, pencolor);
377: else {
378: for (i=0; i<10; i++)
379: for (j=0; j<10; j++)
380: if (penmat[i][j])
381: setmat(wind[curwind].val, GLROW, GLCOL, r+i-4, c+j-4, pencolor);
382: }
383: }
384:
385: /*
386: * setcmd: handle the s command. Format: s <what> <where>.
387: */
388: setcmd()
389: {
390: char what, where;
391:
392: message("set <what>");
393: what = inchar();
394: switch (what) {
395:
396: case 'p': /* set pen */
397: message("set pen <weight>");
398: where = inchar();
399: switch (where) {
400: case 'f': /* set pen fine */
401: case 'l': /* set pen light */
402: message("set pen fine");
403: penweight = 0;
404: break;
405: case 'h': /* set pen heavy */
406: case 'b': /* set pen bold */
407: message("set pen heavy");
408: penweight = 1;
409: break;
410: default:
411: error("Illegal kind of pen weight");
412: }
413: break;
414:
415: case 's': /* set size of heavy pen */
416: message("set pen size to <size>");
417: where = inchar() - '0';
418: sprintf(msgbuf, "set pen size to %d", where);
419: message(msgbuf);
420: if (where > 0 && where < 10) {
421: setpen(where);
422: } else
423: error("Illegal size");
424: break;
425:
426: case 'd':
427: message("set draw");
428: pencolor = 1;
429: break;
430:
431: case 'e':
432: message("set erase");
433: pencolor = 0;
434: break;
435:
436: default:
437: error("Illegal set");
438: }
439: }
440:
441: /*
442: * setpen: set the heavy pen size to s.
443: * Main work here is defining template of pen.
444: */
445: setpen(s)
446: int s;
447: {
448: register int i, j;
449: register float radius;
450:
451: if (s < 1)
452: s = 1;
453: hpensize = s;
454: radius = hpensize;
455: radius /= 2;
456: for (i=0; i<10; i++) {
457: for (j=0; j<10; j++) {
458: penmat[i][j] = (radius >= sqrtmat[abs(i-4)][abs(j-4)]);
459: }
460: }
461:
462: /*
463: * Kludge to make a 2-wide pen possible by specifying 1.
464: */
465: if (hpensize == 1)
466: penmat[4][5] = 1;
467:
468: if (trace)
469: for (i=0; i<10; i++) {
470: for (j=0; j<10; j++) {
471: fprintf(trace, "%c", penmat[i][j] ? 'P' : '.');
472: }
473: fprintf(trace, "\n");
474: }
475: }
476:
477: /*
478: * error: print the given error message and return for another command.
479: */
480: error(msg)
481: char *msg;
482: {
483: message(msg);
484: longjmp(env);
485: }
486:
487: /*
488: * copymove: do a move or copy command.
489: * cmd is C or M, the command.
490: */
491: copymove(cmd)
492: char cmd;
493: {
494: char *action;
495: char src, dest;
496: bitmat cpy;
497: char lochr[5];
498:
499: if (cmd == 'C')
500: action = "copy";
501: else
502: action = "move";
503: sprintf(msgbuf, "%s <from>", action);
504: message(msgbuf);
505: src = inchar();
506: sprintf(msgbuf, "%s %s to <to>", action, rdchar(src));
507: message(msgbuf);
508: dest = inchar();
509: strcpy(lochr, rdchar(src));
510: sprintf(msgbuf, "%s %s to %s", action, lochr, rdchar(dest));
511: message(msgbuf);
512:
513: /* Do the copy */
514: disptable[dest] = disptable[src];
515: cht[dest] = cht[src];
516: if (cht[dest].wherewind >= 0)
517: wind[cht[dest].wherewind].used = dest;
518:
519: if (cmd == 'C') {
520: if (cht[dest].wherewind != -1) {
521: /*
522: * Make copies of the window so changing
523: * one won't change the other.
524: * The old copy gets the window on the screen, if any,
525: * relegating the new copy to the background.
526: */
527: cpy = newmat(GLROW, GLCOL);
528: if (cht[dest].wherewind >= 0)
529: bitcopy(cpy, wind[cht[src].wherewind].val, GLROW, GLCOL);
530: else
531: bitcopy(cpy, cht[src].whereat, GLROW, GLCOL);
532: if (cht[dest].wherewind == curwind)
533: curwind = -1;
534: cht[dest].wherewind = -2;
535: cht[dest].whereat = cpy;
536: }
537: } else {
538: /*
539: * Move. Delete the old entries.
540: */
541: disptable[src].addr = disptable[src].nbytes = 0;
542: cht[src].wherewind = -1;
543: }
544: changes++;
545: }
546:
547: /*
548: * cch: make sure there is a current character.
549: */
550: cch()
551: {
552: if (curwind < 0)
553: error("No current glyph");
554: }
555:
556: /*
557: * confirm: if there have been changes, ask user if he is sure.
558: */
559: confirm()
560: {
561: char ch;
562:
563: if (changes == 0)
564: return;
565: message("Changes since last write -- Are you sure?");
566: ch = inchar();
567: if (isupper(ch))
568: ch = tolower(ch);
569: switch (ch) {
570: case 'y':
571: case 'q':
572: case 'e':
573: return;
574: case 'n':
575: default:
576: error("Not sure - aborted");
577: }
578: }
579:
580: /*
581: * delchar: the D command. Delete a character from the buffer.
582: */
583: delchar()
584: {
585: register char c, c1, c2;
586: register int w;
587: char buf[5];
588:
589: message("delete <char>");
590: c1 = inchar();
591: sprintf(msgbuf, "delete %s through <char>", rdchar(c1));
592: message(msgbuf);
593: c2 = inchar();
594: strcpy(buf, rdchar(c1));
595: sprintf(msgbuf, "delete %s through %s", buf, rdchar(c2));
596: message(msgbuf);
597: changes++;
598:
599: for (c=c1; c<=c2; c++) {
600: if ((w = cht[c].wherewind) >= 0) {
601: zermat(wind[w].val, GLROW, GLCOL);
602: syncwind(w);
603: }
604: cht[c].wherewind = -1;
605: disptable[c].addr = 0;
606: disptable[c].nbytes = 0;
607: disptable[c].up = 0;
608: disptable[c].down = 0;
609: disptable[c].left = 0;
610: disptable[c].right = 0;
611: disptable[c].width = 0;
612: }
613: }
614:
615: /*
616: * zoom out to full screen so the screen doean't go nuts when we
617: * print off the current zoom window. Save old value of zoom in
618: * oldzoom so space can put us back.
619: */
620: zoomout()
621: {
622: if (curzoom != 1)
623: zoomn(curzoom = 1);
624: }
625:
626: /*
627: * newglyph: the n command.
628: */
629: newglyph()
630: {
631: register int i, j;
632: int windno;
633: int vertoff, horoff;
634: char *tmp;
635:
636: message("new glyph <char>");
637: curchar = inchar();
638: sprintf(msgbuf, "new glyph %s", rdchar(curchar));
639: message(msgbuf);
640:
641: if (trace)
642: fprintf(trace, "\n\nnewglyph(%s)\n", rdchar(curchar));
643: if (disptable[curchar].nbytes != 0) {
644: if (trace)
645: fprintf(trace, "char exists: %s\n", rdchar(curchar));
646: sprintf(msgbuf, "char exists: %s", rdchar(curchar));
647: error(msgbuf);
648: }
649:
650: turnofcurs();
651: /*
652: * Not on screen. First find a suitable window,
653: * using round robin.
654: */
655: windno = nextwind;
656: if (trace)
657: fprintf(trace, "chose window %d\n", windno);
658: if (++nextwind >= NWIND)
659: nextwind = 0;
660: #ifdef notdef
661: if (nextwind >= 3)
662: nextwind = 0;
663: #endif
664: wind[windno].used = curchar;
665:
666: /* Put a box around the current window */
667: if (windno != curwind) {
668: drawbox(base[curwind].r-1, base[curwind].c-1, 0, GLROW+2, GLCOL+2);
669: drawbox(base[windno].r-1, base[windno].c-1, 1, GLROW+2, GLCOL+2);
670: }
671:
672: /* Print the char at the lower left of the window */
673: sprintf(msgbuf, "%s", rdchar(curchar));
674: dispmsg(msgbuf, base[windno].c, base[windno].r-11, 2);
675:
676: /* Now make room in the window */
677: if (wind[windno].onscreen == NULL) {
678: /* Brand new window, have to allocate space */
679: wind[windno].onscreen = newmat(GLROW, GLCOL);
680: } else {
681: /* Save prev glyph for later */
682: cht[wind[curchar].used].whereat = wind[windno].val;
683: cht[wind[curchar].used].wherewind = -2;
684: }
685: if (wind[windno].undval != NULL) {
686: if (trace)
687: fprintf(trace, "newglyph frees undo: %x\n", wind[windno].undval);
688: free(wind[windno].undval);
689: }
690: wind[windno].undval = NULL;
691:
692: /*
693: * Vertical & horizontal offsets. Line up the baseline
694: * of the char at BASELINE from bottom, but center
695: * horizontally.
696: */
697: wind[windno].val = newmat(GLROW, GLCOL);
698:
699: curwind = windno;
700: cht[curchar].wherewind = windno;
701: cht[curchar].rcent = curs_r = GLROW - BASELINE;
702: cht[curchar].ccent = curs_c = GLCOL / 2;
703:
704: #ifdef notdef
705: dumpmat("wind[windno].onscreen", wind[windno].onscreen, GLROW, GLCOL);
706: #endif
707: syncwind(windno);
708:
709: /*
710: * Mung the zoom out to 1 and back. This is needed to
711: * re-center the glyph on the screen if zoomed in, otherwise
712: * if you move by one window it puts the cursor way over at
713: * the right with only half the window visible.
714: */
715: if ((i = curzoom) > 1) {
716: zoomn(1);
717: zoomn(i);
718: }
719: }
720:
721: /*
722: * numedit: change one of the numerical parameters.
723: */
724: numedit()
725: {
726: short * sp = 0;
727: char * cp = 0;
728: char c, f;
729: char *fld;
730: short ovalue, nvalue;
731: char numb[20];
732:
733: message("number of <char>");
734: c = inchar();
735: sprintf(msgbuf, "number of %s <field>", rdchar(c));
736: message(msgbuf);
737: f = inchar();
738:
739: switch (f) {
740: case 'a': sp = (short *)
741: &disptable[c].addr; fld = "addr"; break;
742: case 'n': sp = &disptable[c].nbytes; fld = "nbytes"; break;
743: case 'u': cp = &disptable[c].up; fld = "up"; break;
744: case 'd': cp = &disptable[c].down; fld = "down"; break;
745: case 'l': cp = &disptable[c].left; fld = "left"; break;
746: case 'r': cp = &disptable[c].right; fld = "right"; break;
747: case 'w': sp = &disptable[c].width; fld = "width"; break;
748: case 's': sp = (short *) &disptable[c].nbytes;
749: fld = "size"; break;
750: default: error("No such field");
751: }
752:
753: ovalue = sp ? *sp : *cp;
754: sprintf(msgbuf, "number of %s %s (old value %d) is ", rdchar(c), fld, ovalue);
755: readline(msgbuf, numb, sizeof numb);
756: nvalue = atoi(numb);
757: if (cp)
758: *cp = nvalue;
759: else
760: *sp = nvalue;
761: changes++;
762: }
763:
764: /*
765: * These routines turn the cursor and rubber band line on and off,
766: * remembering its state for the o and r commands.
767: */
768: turnoncurs()
769: {
770: curon();
771: curcurs = 1;
772: }
773:
774: turnofcurs()
775: {
776: curoff();
777: curcurs = 0;
778: }
779:
780: turnonrb()
781: {
782: rbon();
783: currb = 1;
784: }
785:
786: turnofrb()
787: {
788: rboff();
789: currb = 0;
790: }
791:
792: synccurs()
793: {
794: register int x, y;
795:
796: x = base[curwind].c + curs_c;
797: y = base[curwind].r + GLROW - curs_r - 1;
798: movecurs(x, y);
799: }
800:
801: inchar()
802: {
803: sync();
804: synccurs();
805: return (rawchar());
806: }
807:
808: /*
809: * fillin - fill in with 1's all the spots that are in the enclosed
810: * area that (x, y) is in.
811: */
812: fillin(x, y)
813: int x, y;
814: {
815: if (x<0 || x>=GLROW || y<0 || y>=GLCOL ||
816: mat(wind[curwind].val, GLROW, GLCOL, x, y))
817: return;
818:
819: setmat(wind[curwind].val, GLROW, GLCOL, x, y, 1);
820: fillin(x-1, y);
821: fillin(x+1, y);
822: fillin(x, y-1);
823: fillin(x, y+1);
824: }
825:
826: /*
827: * syncwind: make sure that window #n shows on the screen what it's
828: * supposed to after an arbitrary change.
829: */
830: syncwind(n)
831: int n;
832: {
833: if (trace)
834: fprintf(trace, "syncwind(%d)\n", n);
835: update(wind[n].onscreen, wind[n].val, GLROW, GLCOL, base[n].r, base[n].c);
836: bitcopy(wind[n].onscreen, wind[n].val, GLROW, GLCOL);
837: }
838:
839: /*
840: * Embolden artificially emboldens the glyphs in the font by smearing
841: * them to the right by the current heavy pen size. Or else italicize it.
842: */
843: artificial()
844: {
845: int low, high, cur;
846: int oldps, newps;
847: char lowch[10];
848: #define ITAL 0
849: #define BOLD 1
850: #define RESIZE 2
851: #define SMOOTH 3
852: int kind;
853: char *strbold;
854:
855: sprintf(msgbuf, "Artificially <embolden/italicize/resize/smooth>");
856: message(msgbuf);
857:
858: cur = inchar();
859: switch(cur) {
860: case 'i': case 'I': kind = ITAL; strbold = "italicize"; break;
861: case 'e': case 'E': kind = BOLD; strbold = "embolden"; break;
862: case 'r': case 'R': kind = RESIZE; strbold = "resize"; break;
863: case 's': case 'S': kind = SMOOTH; strbold = "smooth"; break;
864: default: error("No such artificial operation");
865: }
866:
867: sprintf(msgbuf, "Artificially %s glyphs from <char>", strbold);
868: message(msgbuf);
869: low = inchar();
870: strcpy(lowch, rdchar(low));
871: sprintf(msgbuf, "Artificially %s glyphs from %s to <char>", strbold, lowch);
872: message(msgbuf);
873: high = inchar();
874: if (kind == RESIZE) {
875: sprintf(msgbuf, "Artificially %s glyphs from %s to %s from <point size>", strbold, lowch, rdchar(high));
876: oldps = readnum(msgbuf);
877: sprintf(msgbuf, "Artificially %s glyphs from %s to %s from %dP to <point size>P", strbold, lowch, rdchar(high), oldps);
878: newps = readnum(msgbuf);
879: sprintf(msgbuf, "Artificially %s glyphs from %s to %s from %dP to %dP", strbold, lowch, rdchar(high), oldps, newps);
880: message(msgbuf);
881: if (oldps <= 0 || oldps > 36 || newps <= 0 || newps > 36 || oldps == newps)
882: error("Bad point sizes");
883: } else {
884: sprintf(msgbuf, "Artificially %s glyphs from %s to %s", strbold, lowch, rdchar(high));
885: message(msgbuf);
886: }
887:
888: for (cur=low; cur<=high; cur++) {
889: getglyph(cur);
890: if (curchar == cur) { /* e.g. if the getglyph succeeded */
891: fflush(stdout);
892: switch (kind) {
893: case BOLD:
894: boldglyph();
895: break;
896: case ITAL:
897: italglyph();
898: break;
899: case RESIZE:
900: if (oldps > newps)
901: shrinkglyph(oldps, newps);
902: else
903: blowupglyph(oldps, newps);
904: break;
905: case SMOOTH:
906: smoothglyph();
907: break;
908: }
909: syncwind(curwind);
910: }
911: }
912: message("Done");
913: }
914:
915: /*
916: * Artificially embolden the current glyph.
917: */
918: boldglyph()
919: {
920: register int r, c, i;
921: int smear = hpensize < 2 ? 2 : hpensize;
922:
923: for (r=0; r<GLROW; r++)
924: for (c=GLCOL-1; c>=smear; c--)
925: for (i=1; i<=smear; i++)
926: if (mat(wind[curwind].val, GLROW, GLCOL, r, c-i))
927: setmat(wind[curwind].val, GLROW, GLCOL, r, c, 1);
928: }
929:
930: /*
931: * Artificially italicize the current glyph.
932: */
933: italglyph()
934: {
935: register int r, c, i, off;
936: int baser = cht[curchar].rcent; /* GLROW - BASELINE; */
937:
938: for (r=0; r<baser; r++) {
939: off = (baser-r) / SLOPE + 0.5;
940: for (c=GLCOL-1; c>=off; c--) {
941: setmat(wind[curwind].val, GLROW, GLCOL, r, c,
942: mat(wind[curwind].val, GLROW, GLCOL, r, c-off));
943: }
944: for (c=off-1; c>=0; c--)
945: setmat(wind[curwind].val, GLROW, GLCOL, r, c, 0);
946: }
947: for (r=baser; r<GLROW; r++) {
948: off = (r-baser) * (2.0/7.0) + 0.5;
949: for (c=off; c<GLCOL; c++)
950: setmat(wind[curwind].val, GLROW, GLCOL, r, c-off,
951: mat(wind[curwind].val, GLROW, GLCOL, r, c));
952: for (c=off-1; c>=0; c--)
953: setmat(wind[curwind].val, GLROW, GLCOL, r, c, 0);
954: }
955: }
956:
957: /*
958: * Blow up or shrink a glyph from oldps points to newps points.
959: * The basic idea is that for each on point in the old glyph we
960: * find the corresponding point in the new glyph and copy the value.
961: */
962: shrinkglyph(oldps, newps)
963: int oldps, newps;
964: {
965: float ratio;
966: register int or, oc, nr, nc;
967: int n;
968: bitmat tmp, curw;
969: int baser = cht[curchar].rcent;
970: int basec = cht[curchar].ccent;
971:
972: ratio = (float) newps / (float) oldps;
973: tmp = newmat(GLROW, GLCOL);
974: curw = wind[curwind].val;
975: bitcopy(tmp, curw, GLROW, GLCOL);
976: zermat(curw, GLROW, GLCOL);
977: for (or=0; or<GLROW; or++) {
978: nr = baser + (or-baser)*ratio + 0.5;
979: for (oc=0; oc<GLCOL; oc++) {
980: nc = basec + (oc-basec)*ratio + 0.5;
981: if (nr < 0 || nr >= GLROW || nc < 0 || nc >= GLCOL)
982: n = 0;
983: else
984: n = mat(tmp, GLROW, GLCOL, or, oc);
985: if (n)
986: setmat(curw, GLROW, GLCOL, nr, nc, n);
987: }
988: }
989: disptable[curchar].width = disptable[curchar].width * ratio + 0.5;
990: free(tmp);
991: }
992:
993: /*
994: * blow up a glyph. Otherwise like shrinkglyph.
995: */
996: blowupglyph(oldps, newps)
997: int oldps, newps;
998: {
999: float ratio;
1000: register int or, oc, nr, nc;
1001: int n;
1002: bitmat tmp, curw;
1003: int baser = cht[curchar].rcent;
1004: int basec = cht[curchar].ccent;
1005:
1006: ratio = (float) oldps / (float) newps;
1007: tmp = newmat(GLROW, GLCOL);
1008: curw = wind[curwind].val;
1009: bitcopy(tmp, curw, GLROW, GLCOL);
1010: zermat(curw, GLROW, GLCOL);
1011: for (nr=0; nr<GLROW; nr++) {
1012: or = baser + (nr-baser)*ratio + 0.5;
1013: for (nc=0; nc<GLCOL; nc++) {
1014: oc = basec + (nc-basec)*ratio + 0.5;
1015: if (or < 0 || or >= GLROW || oc < 0 || oc >= GLCOL)
1016: n = 0;
1017: else
1018: n = mat(tmp, GLROW, GLCOL, or, oc);
1019: if (n)
1020: setmat(curw, GLROW, GLCOL, nr, nc, n);
1021: }
1022: }
1023: disptable[curchar].width = disptable[curchar].width / ratio + 0.5;
1024: free(tmp);
1025: }
1026:
1027: /*
1028: * Smooth a glyph. We look for corners and trim the point. Corners of
1029: * both blanks and dots in all 4 orientations are looked for.
1030: */
1031: smoothglyph()
1032: {
1033: bitmat tmp, curw;
1034: register int r, c;
1035: register int c3;
1036: int a3, b2, b3, b4, c1, c2, c4, c5, d2, d3, d4, e3;
1037:
1038: tmp = newmat(GLROW, GLCOL);
1039: curw = wind[curwind].val;
1040: bitcopy(tmp, curw, GLROW, GLCOL);
1041: for (r=2; r<GLROW-2; r++)
1042: for (c=2; c<GLCOL-2; c++) {
1043: /*
1044: * a3
1045: * b2 b3 b4
1046: * c1 c2 c3 c4 c5
1047: * d2 d3 d4
1048: * d4
1049: * where c3 is the square we are interested in
1050: */
1051: b3 = mat(tmp, GLROW, GLCOL, r-1, c );
1052: c2 = mat(tmp, GLROW, GLCOL, r , c-1);
1053: c4 = mat(tmp, GLROW, GLCOL, r , c+1);
1054: d3 = mat(tmp, GLROW, GLCOL, r+1, c );
1055: /* exactly 2 of the 4 neighbors must be dots */
1056: if (b3+c2+c4+d3 != 2) continue;
1057:
1058: c3 = mat(tmp, GLROW, GLCOL, r , c );
1059: b2 = mat(tmp, GLROW, GLCOL, r-1, c-1);
1060: b4 = mat(tmp, GLROW, GLCOL, r-1, c+1);
1061: d2 = mat(tmp, GLROW, GLCOL, r+1, c-1);
1062: d4 = mat(tmp, GLROW, GLCOL, r+1, c+1);
1063: /* exactly one of the 4 diags must match the center */
1064: if (b2+b4+d2+d4 != 3 - 2*c3) continue;
1065:
1066: a3 = mat(tmp, GLROW, GLCOL, r-2, c );
1067: c1 = mat(tmp, GLROW, GLCOL, r , c-2);
1068: c5 = mat(tmp, GLROW, GLCOL, r , c+2);
1069: e3 = mat(tmp, GLROW, GLCOL, r+2, c );
1070:
1071: /* Figure out which of the 4 directions */
1072: if (b2==c3) {
1073: if (b3+c2+c1+a3 != 4*c3) continue;
1074: } else
1075: if (b4==c3) {
1076: if (b3+c4+c5+a3 != 4*c3) continue;
1077: } else
1078: if (d2==c3) {
1079: if (d3+c2+c1+e3 != 4*c3) continue;
1080: } else
1081: if (d4==c3) {
1082: if (d3+c4+c5+e3 != 4*c3) continue;
1083: }
1084:
1085: /* It must be a corner. Toggle it. */
1086: setmat(curw, GLROW, GLCOL, r, c, !c3);
1087: }
1088: free(tmp);
1089: }
1090:
1091: /*
1092: * Read a number from bottom line ala readline.
1093: * This should probably go in lib2648.
1094: */
1095: int
1096: readnum(prompt)
1097: char *prompt;
1098: {
1099: char buf[10];
1100: int retval;
1101:
1102: readline(prompt, buf, sizeof buf);
1103: retval = atoi(buf);
1104: if (trace)
1105: fprintf(trace, "readline returns '%s', retval=%d\n", buf, retval);
1106: return (retval);
1107: }
1108:
1109: invert()
1110: {
1111: register int r, c;
1112: int tmp1, tmp2, kind;
1113: bitmat curw = wind[curwind].val;
1114:
1115: message("Invert <horizontally/vertically>");
1116: kind = inchar();
1117: switch (kind) {
1118: case 'h': case 'H':
1119: message("Invert horizontally");
1120: for (r=0; r<GLROW; r++) {
1121: if (trace)
1122: fprintf(trace, "row %d\n", r);
1123: for (c=0; c<=(GLCOL-1)/2; c++) {
1124: tmp1 = mat(curw, GLROW, GLCOL, r, c);
1125: tmp2 = mat(curw, GLROW, GLCOL, r, GLCOL-1-c);
1126: if (trace)
1127: fprintf(trace, "cols %d (%d) <=> %d (%d)\n", c, tmp1, GLCOL-1-c, tmp2);
1128: setmat(curw, GLROW, GLCOL, r, c, tmp2);
1129: setmat(curw, GLROW, GLCOL, r, GLCOL-1-c, tmp1);
1130: }
1131: }
1132: break;
1133: case 'v': case 'V':
1134: message("Invert vertically");
1135: for (c=0; c<GLCOL; c++) {
1136: for (r=0; r<=(GLROW-1)/2; r++) {
1137: tmp1 = mat(curw, GLROW, GLCOL, r, c);
1138: tmp2 = mat(curw, GLROW, GLCOL, GLROW-1-r, c);
1139: setmat(curw, GLROW, GLCOL, r, c, tmp2);
1140: setmat(curw, GLROW, GLCOL, GLROW-1-r, c, tmp1);
1141: }
1142: }
1143: break;
1144: default:
1145: error("Bad choice");
1146: }
1147: syncwind(curwind);
1148: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.