![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Tplot.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 / xterm|
Return to Tplot.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / xterm |
1.1 root 1: #include <X/mit-copyright.h>
2:
3: /* Copyright 1984, 1985 Massachusetts Institute of Technology */
4: /* Tplot.c */
5:
6: #ifndef lint
7: static char *rcsid_Tplot_c = "$Header: Tplot.c,v 10.8 86/02/01 16:05:23 tony Rel $";
8: #endif lint
9:
10: #include <X/Xlib.h>
11: #include "ptyx.h"
12: #undef CTRL
13: #include <stdio.h>
14: #include <sys/file.h>
15: #include <sgtty.h>
16: #include <pwd.h>
17: #undef CTRL
18:
19: extern debug;
20:
21: static int bplot[5];
22: static int nplot;
23: static int ipchr;
24: static int refresh;
25: static int LoYSet;
26:
27: #define MAX_PTS 150
28: #define MAX_VTX 300
29: static Vertex Tline[MAX_VTX];
30: static Vertex *line_pt;
31:
32: static FILE *rfile, *wfile;
33:
34: static TekLink *TekBuf = NULL;
35: TekLink *tb_end_link = NULL; /* world accessible for TekBufPut */
36: int tb_end = TEK_LINK_BLOCK_SIZE; /* world accessible for TekBufPut */
37: static TekLink *tb_pt_link = NULL;
38: static int tb_pt = TEK_LINK_BLOCK_SIZE;
39:
40: #include "../cursors/tcross.cursor"
41: #include "../cursors/tcross_mask.cursor"
42:
43: TekErase (term)
44:
45: /* Reset buffer pointer for display list to start of buffer */
46:
47: Terminal *term;
48: {
49: register Screen *screen = &term->screen;
50: register struct _TekLink *pnt;
51: register struct _TekLink *next;
52:
53: pnt = (struct _TekLink *) TekBuf;
54:
55: /* free stored list */
56: while (pnt)
57: {
58: next = pnt->next;
59: free (pnt);
60: pnt = next;
61: }
62:
63: /* reset pointers */
64: TekBuf = tb_end_link = tb_pt_link = NULL;
65: tb_end = tb_pt = TEK_LINK_BLOCK_SIZE;
66:
67: refresh = 0;
68: screen->cur_x = 0;
69: screen->cur_y = 0;
70: screen->TekGMode = 0;
71: screen->TekAMode = 0;
72: LoYSet = 0;
73:
74: if (debug) wfile = fopen ("testbufw","w");
75:
76: return;
77: }
78:
79:
80: TekRefresh (term)
81:
82: /* Redisplay graphics screen, including positioned alpha strings */
83:
84: register Terminal *term;
85: {
86: register Screen *screen = &term->screen;
87: Window window = screen->window;
88: Font fnt = screen->fnt_norm;
89: int chr, nstr;
90: register int ch;
91: unsigned char str[257];
92: int modeG = screen->TekGMode, modeA = screen->TekAMode,
93: modeI = screen->TekIMode, modeP = screen->TekPMode;
94:
95: TekBufResetPt ();
96:
97: if (TekBufEmpty ()) return;
98:
99: if (debug) rfile = fopen ("testbufr","w");
100:
101: refresh = 1;
102: TekAlph (term,0);
103: screen->cur_x = screen->cur_y = 0;
104:
105: while (TekBufGet (&chr) != -1)
106: {
107: ch = chr; /* lets get the char into a register */
108: if (screen->TekGMode)
109: {
110: if (ch > 31)
111: {
112: if (screen->TekIMode) TekPoint (term,ch);
113: else TekPlot (term,ch);
114: }
115: else if (ch > 27 && ch < 31) TekInit (term,ch);
116: else if (ch == 31 || ch < 28) TekAlph (term,0);
117: continue;
118: }
119:
120: if (ch > 27 && ch < 31)
121: {
122: TekInit (term, ch);
123: continue;
124: }
125:
126: if (ch > (unsigned) 128)
127: {
128: nstr = ch - (unsigned) 128;
129:
130: if (debug)
131: {
132: fprintf (rfile,"alpha mode %d chars\n",nstr);
133: fflush (rfile);
134: }
135:
136: if (nstr > 256) exit (77);
137: TekBufGetString (str, nstr);
138: *(str + nstr) = NULL;
139:
140: XTextMask ( window,
141: TCursorX(screen), TCursorY(screen),
142: str, nstr, fnt, screen->foreground);
143:
144: screen->cur_X += (nstr * screen->f_width);
145: screen->cur_x +=
146: (nstr * screen->f_width / screen->TekScale);
147: }
148: }
149:
150: if (nplot > 0) TekFlush (term);
151: refresh = 0;
152:
153: screen->TekGMode = modeG;
154: screen->TekAMode = modeA;
155: screen->TekIMode = modeI;
156: screen->TekPMode = modeP;
157: }
158:
159:
160: TekString (term, str, nchr)
161:
162: /* Display positioned alphanumeric string, saving it in display list */
163:
164: register Terminal *term;
165: unsigned char *str;
166: int nchr;
167: {
168: register Screen *screen = &term->screen;
169: Window window = screen->window;
170: Font fnt = screen->fnt_norm;
171:
172: TekBufPut (128 + nchr);
173: if (debug)
174: {
175: fprintf (wfile,"alpha mode %d character string\n",nchr);
176: fflush (wfile);
177: }
178:
179: TekBufPutString (str, nchr);
180:
181: XTextMask (window,
182: TCursorX(screen), TCursorY(screen),
183: str, nchr, fnt, screen->foreground);
184:
185: screen->cur_X = screen->cur_X + (nchr * screen->f_width);
186: screen->cur_x = screen->cur_x +
187: (nchr * screen->f_width / screen->TekScale);
188: }
189:
190: TekBufResetPt ()
191: /* set pt to point to beginning of buffer */
192: {
193: tb_pt_link = TekBuf;
194: tb_pt = 0;
195: }
196:
197: TekBufEmpty ()
198: /* return nonzero iff TekBuf is empty */
199: {
200: return (((tb_end & ~TEK_LINK_BLOCK_SIZE) == 0)
201: && (tb_end_link == TekBuf));
202: }
203:
204:
205: /* Extend display buffer */
206: TekBufExtend ()
207: {
208:
209: /* if TekBuf is NULL then must initialize */
210: if (!TekBuf)
211: {
212: TekBuf = (TekLink *) malloc (sizeof (TekLink));
213: TekBuf->next = NULL;
214: tb_end_link = TekBuf;
215: tb_end = 0;
216: }
217: else
218: {
219: tb_end_link->next =
220: (struct _TekLink *) malloc (sizeof (TekLink));
221: tb_end_link = (TekLink *) tb_end_link->next;
222: tb_end_link->next = NULL;
223: tb_end = 0;
224: }
225: }
226:
227: /*
228: effect: puts len bytes at str into display buffer
229: */
230: TekBufPutString (str, len)
231: register unsigned char *str;
232: register int len;
233: {
234: register int amount;
235:
236: while (len)
237: {
238: if (tb_end & TEK_LINK_BLOCK_SIZE) TekBufExtend ();
239:
240: amount = TEK_LINK_BLOCK_SIZE - tb_end;
241: if (amount > len) amount = len;
242:
243: bcopy (str, tb_end_link->data + tb_end, amount);
244: str += amount;
245: len -= amount;
246: tb_end += amount;
247: }
248: }
249:
250:
251: /* Read character from display list */
252:
253: int TekBufGet (chr)
254: register unsigned int *chr;
255: {
256: if (tb_pt & TEK_LINK_BLOCK_SIZE)
257:
258: /* if tb_pt_link is NULL then check for a TekBuf */
259: if (!tb_pt_link)
260: {
261: if (!TekBuf) return (-1);
262: tb_pt_link = TekBuf;
263: tb_pt = 0;
264: }
265: else
266: if (tb_pt_link->next == NULL) return (-1);
267: else
268: {
269: tb_pt_link = (TekLink *) tb_pt_link->next;
270: tb_pt = 0;
271: }
272:
273: if ((tb_pt_link == tb_end_link) && (tb_pt >= tb_end)) return (-1);
274:
275: *chr = tb_pt_link->data [tb_pt++];
276: return (0);
277: }
278:
279: /* store next len characters of TekBuf in str, advancing tb_pt */
280: TekBufGetString (str, len)
281: register char *str;
282: register int len;
283: {
284: register int n;
285:
286: while (len)
287: {
288: n = TEK_LINK_BLOCK_SIZE - tb_pt;
289: n = (n < len) ? n : len;
290:
291: bcopy (tb_pt_link->data + tb_pt, str, n);
292: tb_pt += n;
293: len -= n;
294: str += n;
295:
296: if (tb_pt == TEK_LINK_BLOCK_SIZE)
297: {
298: if (tb_pt_link->next == NULL) return;
299: tb_pt_link = (TekLink *) tb_pt_link->next;
300: tb_pt = 0;
301: }
302: }
303: }
304:
305: /* Switch to graphics mode and initialize byte and point counters */
306:
307: TekInit (term,chr)
308: Terminal *term;
309: register int chr;
310: {
311: register Screen *screen = &term->screen;
312:
313: if (debug)
314: if (!refresh)
315: {
316: fprintf (wfile,"switching to graphics mode %d\n",chr);
317: fflush (wfile);
318: }
319: else
320: {
321: fprintf (rfile,"switching to graphics mode %d\n",chr);
322: fflush (rfile);
323: }
324:
325: if (!screen->TekGMode && nplot > 0) TekFlush (term);
326:
327: screen->pen = 0;
328: ipchr = 0;
329: screen->TekPMode = 0;
330: screen->TekIMode = 0;
331: if (chr == 28) screen->TekPMode = 1;
332: if (chr == 30) screen->TekIMode = 1;
333:
334: if (!refresh) TekBufPut (chr);
335: if (screen->TekGMode) return;
336:
337: nplot = 0;
338: screen->TekGMode = 1;
339: screen->TekAMode = 1;
340: /*
341: * screen->cur_row = 0;
342: * screen->cur_col = 0;
343: */
344: line_pt = Tline;
345: }
346:
347: TekAlph (term,chr)
348:
349: /* Switch back to alphanumeric mode from graphics mode */
350:
351: Terminal *term;
352: int chr;
353: {
354: register Screen *screen = &term->screen;
355:
356: if (!screen->TekGMode) return;
357:
358: if (debug)
359: if (!refresh)
360: {
361: fprintf (wfile,"switching to alpha mode %d\n",chr);
362: fflush (wfile);
363: }
364: else
365: {
366: fprintf (rfile,"switching to alpha mode %d\n",chr);
367: fflush (rfile);
368: }
369:
370: if (!refresh) TekBufPut (chr);
371: if (nplot > 0) TekFlush (term);
372:
373: screen->TekGMode = 0;
374: screen->TekPMode = 0;
375: screen->TekIMode = 0;
376: if (chr>0 && chr != 31) TekReset(term);
377: return;
378: }
379:
380:
381: TekReset (term)
382:
383: /* Switch back to vt100 alphanumeric mode from Tektronix alphanumeric mode
384: * This allows alphanumeric strings to be positioned by graphics commands,
385: * but reenables scrolling after CR or LF. */
386:
387: Terminal *term;
388: {
389: register Screen *screen = &term->screen;
390: int fh = screen->f_height;
391: int fw = screen->f_width;
392:
393: screen->TekAMode = 0;
394:
395: if (debug)
396: if (!refresh)
397: {
398: fprintf (wfile,"resetting to alpha mode\n");
399: fflush (wfile);
400: }
401: else
402: {
403: fprintf (rfile,"resetting to alpha mode\n");
404: fflush (rfile);
405: }
406:
407: if (screen->cur_Y > 0)
408: {
409: screen->cur_row = (screen->cur_Y - (fh >> 1)) / fh;
410: if (screen->cur_row > screen->max_row)
411: screen->cur_row = screen->max_row;
412: screen->cur_Y = 0;
413: }
414: if (screen->cur_X > 0)
415: {
416: screen->cur_col = (screen->cur_X + (fw >> 1)) / fw;
417: if (screen->cur_col > screen->max_col)
418: screen->cur_col = screen->max_col;
419: screen->cur_X = 0;
420: }
421: screen->cur_x = 0;
422: screen->cur_y = 0;
423:
424: return;
425: }
426:
427:
428: TekCursor (term)
429:
430: /* Reads position of mouse cursor when a character is typed and returns
431: * it in Tektronix-format coordinates */
432:
433: Terminal *term;
434: {
435: register Screen *screen = &term->screen;
436: Keyboard *keyboard = &term->keyboard;
437: register Window window = screen->window;
438: int MouseX, MouseY;
439: XEvent reply;
440: XEvent *rep = &reply;
441: Window subw;
442: int pty = screen->respond;
443: int keycode, event, shifts;
444: short c;
445: char cplot [5];
446: extern int wflush ();
447: int x, y;
448: Cursor cursor;
449: char *string = " ";
450: int nbytes;
451:
452: TekAlph (term, 0);
453: TekReset (term);
454:
455: /* Set cross-hair cursor raster array */
456: cursor = XCreateCursor(tcross_width, tcross_height,
457: tcross_bits, tcross_bits, 7, 7,
458: screen->foreground, screen->background, GXxor);
459:
460: /* Display cross-hair cursor */
461: XDefineCursor(window, cursor);
462:
463: /* reselect input. Must be careful not to leave stray button
464: * events upon return since handle buttons would be invoked */
465:
466: XSelectInput (window, ButtonReleased | KeyPressed);
467:
468: /* Wait for keyboard entry */
469: XWindowEvent (window, KeyPressed | ButtonReleased, &reply);
470:
471: keycode = ((XKeyOrButtonEvent *)rep)->detail;
472: event = reply.type;
473:
474: /* Get current mouse position and translate to screen coordinates */
475: XUpdateMouse (window, &MouseX, &MouseY, &subw);
476:
477: x = ((MouseX - screen->border) << 1);
478: y = 782 - ((MouseY - screen->border) << 1);
479: screen->cur_X = MouseX;
480: screen->cur_Y = MouseY;
481:
482: /* Translate x and y to Tektronix code */
483: cplot[1] = 32 + (x >> 5);
484: cplot[2] = 32 + (x & 31);
485: cplot[3] = 32 + (y >> 5);
486: cplot[4] = 32 + (y & 31);
487:
488: /* Translate keyboard entry and return one byte from terminal */
489: if (event == KeyPressed)
490: {
491: string = XLookupMapping ((XKeyPressedEvent *)& reply, &nbytes);
492: c = *string;
493: }
494: else c = keycode + 48;
495:
496: cplot[0] = c;
497:
498: /* Return encode screen coordinates */
499: write (pty, cplot, 5 * sizeof (char));
500:
501: /* Reset cursor and return */
502:
503: XFreeCursor(cursor);
504: XDefineCursor(window,
505: (term->flags & INVERSE) ? screen->rcurs : screen->curs);
506:
507:
508: TekInit (term,0);
509:
510: XSelectInput (window, KeyPressed | ExposeWindow | ExposeRegion |
511: ExposeCopy | ButtonPressed | ButtonReleased);
512: }
513:
514:
515: TekPlot (term,chr)
516:
517: /* Translates Tektronix byte-encoded screen coordinates to integer screen
518: * coordinates each time the final byte of a coordinate set is encountered. */
519:
520: Terminal *term;
521: register int chr;
522: {
523: register Screen *screen = &term->screen;
524: register int *bp = bplot;
525: register int x, y;
526:
527: ipchr++;
528: if (ipchr > 5)
529: {
530: TekAlph (term,chr);
531: return;
532: }
533:
534: /* decode Tektronix byte position codes */
535:
536: if (chr < 64)
537: {
538: if (LoYSet) /* 4st byte */
539: {
540: bp[3] = chr & ~32;
541: }
542: else /* 1st byte */
543: {
544: bp[0] = chr & ~32;
545: bp[1] = 0;
546: }
547: }
548: else if (chr > 95)
549: {
550: if (LoYSet) /* 2nd byte */
551: { /* 3rd if 2nd present */
552: bp[1] = bp[2];
553: bp[2] = chr & ~96;
554: }
555: else /* 3rd byte */
556: {
557: bp[2] = chr & ~96;
558: bp[1] = 0;
559: LoYSet = 1;
560: }
561: }
562: else /* 5th byte */
563: {
564: bp[4] = chr & ~64;
565: ipchr = 0;
566: LoYSet = 0;
567:
568: /* compute screen x and y coordinates ignoring extended
569: * precision byte */
570:
571: y = (bp[0] << 7) + (bp[2] << 2);
572: x = (bp[3] << 7) + (bp[4] << 2);
573:
574: /* add in 4014 extended precision byte */
575: if (bp[1] > 0)
576: {
577: x += (bp [1] & 3);
578: y += ((bp [1] & 12) >> 2);
579: }
580:
581: /* Check to make sure screen limits are not exceeded */
582: if (y > 3127) y = 3127;
583:
584: /* transfer this point to vertex array */
585: if (screen->TekPMode)
586: {
587: TekDraw (0, x, y, term);
588: TekDraw (1, x, y, term);
589: }
590: else
591: {
592: TekDraw (screen->pen, x, y, term);
593: screen->pen = 1;
594: }
595: }
596: }
597:
598:
599: TekPoint (term,chr)
600:
601: /* Translates Tektronix byte-encoded incremental plot commands to screen
602: * coordinates and writes them to the vector buffer */
603:
604: register Terminal *term;
605: register int chr;
606: {
607: Screen *screen = &term->screen;
608: register int pen,x,y;
609:
610: x = screen->cur_x;
611: y = screen->cur_y;
612: pen = screen->pen;
613:
614: if (nplot == 0) TekDraw (0,x,y,term);
615:
616: switch (chr)
617: {
618: case ' ': screen->pen = 0;
619: break;
620:
621: case 'P': screen->pen = 1;
622: break;
623:
624: case 'D': TekDraw (pen, x, ++y, term);
625: break;
626:
627: case 'E': TekDraw (pen, ++x, ++y, term);
628: break;
629:
630: case 'A': TekDraw (pen, ++x, y, term);
631: break;
632:
633: case 'I': TekDraw (pen, ++x, --y, term);
634: break;
635:
636: case 'H': TekDraw (pen, x, --y, term);
637: break;
638:
639: case 'J': TekDraw (pen, --x, --y, term);
640: break;
641:
642: case 'B': TekDraw (pen, --x, y, term);
643: break;
644:
645: case 'F': TekDraw (pen, --x, ++y, term);
646: break;
647:
648: }
649: }
650:
651:
652: TekDraw (pen, x, y, term)
653:
654: /* Translates Tektronix screen coordinates to vs100 screen
655: * coordinates, drawing them to the screen when a buffer is filled */
656:
657: int x,y,pen;
658: Terminal *term;
659: {
660: register Screen *screen = &term->screen;
661: register Vertex *lp = line_pt;
662:
663: screen->cur_x = x;
664: screen->cur_y = y;
665:
666: /* convert to vs100 window coordinates */
667: screen->cur_X = (x + 1) * screen->TekScale + screen->border;
668: screen->cur_Y = (3128 - y) * screen->TekScale + screen->border;
669:
670: /* write to plot buffer */
671: lp->x = screen->cur_X;
672: lp->y = screen->cur_Y;
673:
674: if (pen) lp->flags = VertexDrawLastPoint;
675: else lp->flags = VertexDontDraw;
676:
677: lp = ++line_pt;
678: nplot++;
679:
680: if (debug)
681: if (refresh) fprintf (rfile,"%d: %d %d,%d -> %d,%d\n",
682: nplot,pen,x,y,screen->cur_X,screen->cur_Y);
683: else fprintf (wfile,"%d: %d %d,%d -> %d,%d\n",
684: nplot,pen,x,y,screen->cur_X,screen->cur_Y);
685: if (debug)
686: if (refresh) fflush (rfile);
687: else fflush (wfile);
688:
689: /* draw line if buffer limit has been reached */
690: if (nplot >= MAX_PTS)
691: {
692: TekFlush (term);
693: lp = line_pt;
694: lp->x = screen->cur_X;
695: lp->y = screen->cur_Y;
696: lp->flags = VertexDontDraw;
697: line_pt++;
698: nplot++;
699: }
700: }
701:
702:
703: TekFlush (term)
704:
705: register Terminal *term;
706: {
707: Window window = term->screen.window;
708:
709: XDraw (window, Tline, nplot, 1, 1, term->screen.foreground, GXcopy,
710: AllPlanes);
711: nplot = 0;
712:
713: line_pt = Tline;
714: }
715:
716: TekInq (term)
717: /* Reports position of cursor in Tektronix-format coordinates */
718: Terminal *term;
719: {
720: register Screen *screen = &term->screen;
721: int pty = screen->respond;
722: char cplot [5];
723: int x, y;
724: x = ((screen->cur_X - screen->border) << 1);
725: y = 782 - ((screen->cur_Y - screen->border) << 1);
726: /* Translate x and y to Tektronix code */
727: cplot[1] = 32 + (x >> 5);
728: cplot[2] = 32 + (x & 31);
729: cplot[3] = 32 + (y >> 5);
730: cplot[4] = 32 + (y & 31);
731: cplot[0] = '%'; /* standard hardware config */
732: /* Return encoded screen coordinates */
733: write (pty, cplot, 5 * sizeof (char));
734: }
735:
736: #ifdef ENABLE_PRINT
737:
738: #include <signal.h>
739:
740: TekPrint ()
741:
742: /* Dump graphics screen, including positioned alpha strings */
743:
744: {
745: int chr, pid, uid, i;
746: char c;
747: FILE *tekfile;
748: char *uname, tekfile_name[40];
749: struct passwd *upasswd;
750: int temp_tb_pt = tb_pt;
751: TekLink *temp_tb_pt_link = tb_pt_link;
752:
753: TekBufResetPt ();
754: if (TekBufEmpty ()) return;
755:
756: pid = getpid ();
757: uid = getuid ();
758: upasswd = getpwuid (uid);
759: sprintf (tekfile_name,"/tmp/vst%d\.%s\0",pid,upasswd->pw_name);
760:
761: tekfile = fopen (tekfile_name,"w");
762:
763: while (TekBufGet (&chr) != -1)
764: {
765: c = chr;
766: if (chr < 128) putc (c,tekfile);
767: }
768:
769: tb_pt = temp_tb_pt;
770: tb_pt_link = temp_tb_pt_link;
771:
772: fclose (tekfile);
773:
774: if (debug) printf ("attempting fork\n");
775:
776: switch (fork ())
777: {
778: case -1: Error ();
779: break;
780:
781: case 0: for (i= 0; i < _NFILE; i++) close (i);
782: signal(SIGCHLD, SIG_DFL);
783: signal(SIGTERM, SIG_DFL);
784: signal(SIGHUP, SIG_IGN);
785: execlp("imtek", "imtek", "-x",tekfile_name, 0);
786: exit (1);
787: break;
788:
789: default:
790: break;
791: }
792: }
793:
794: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.