![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to screen.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to screen.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: #include "jove.h"
9: #include "fp.h"
10: #include "ctype.h"
11: #include "termcap.h"
12: #include "disp.h"
13:
14: int AbortCnt,
15: CanScroll = 0,
16: tabstop = 8;
17:
18: #if !(defined(IBMPC) || defined(MAC))
19: private void
20: (*TTins_line) proto((int, int, int)),
21: (*TTdel_line) proto((int, int, int));
22: #endif /* (defined(IBMPC) || defined(MAC)) */
23:
24: struct scrimage
25: *DesiredScreen = 0,
26: *PhysScreen = 0;
27:
28: struct screenline *Screen = 0, /* the screen (a bunch of screenline) */
29: *Curline = 0; /* current line */
30:
31: private struct screenline *Savelines = 0; /* another bunch (LI of them) */
32:
33:
34: private char *cursor; /* offset into current Line */
35:
36: char *cursend;
37:
38: int CapCol,
39: CapLine,
40:
41: i_line,
42: i_col;
43:
44: #ifdef IBMPC
45: extern unsigned char CHPL;
46: extern void near normfun(),
47: near scr_win(),
48: near clr_page(),
49: near clr_eoln();
50:
51: #endif
52:
53: void
54: make_scr()
55: {
56: register int i;
57: register struct screenline *ns;
58: register char *nsp;
59:
60: #ifdef RESHAPING
61: /* In case we are RESHAPING the window! */
62: if (DesiredScreen)
63: free((char *) DesiredScreen);
64: if (PhysScreen)
65: free((char *) PhysScreen);
66: if (Savelines)
67: free((char *) Savelines);
68: if (Screen) {
69: free(Screen->s_line); /* free all the screen data */
70: free((char *) Screen);
71: }
72: #endif /* RESHAPING */
73:
74: DesiredScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage));
75: PhysScreen = (struct scrimage *) malloc((unsigned) LI * sizeof (struct scrimage));
76:
77: Savelines = (struct screenline *)
78: malloc((unsigned) LI * sizeof(struct screenline));
79: ns = Screen = (struct screenline *)
80: malloc((unsigned) LI * sizeof(struct screenline));
81:
82: nsp = (char *) malloc((unsigned)CO * LI);
83: if (nsp == 0) {
84: writef("\n\rCannot malloc screen!\n");
85: finish(1);
86: }
87:
88: for (i = 0; i < LI; i++) {
89: ns->s_line = nsp;
90: nsp += CO;
91: ns->s_length = nsp - 1; /* End of Line */
92: ns += 1;
93: }
94: cl_scr(0);
95: }
96:
97: void
98: clrline(cp1, cp2)
99: register char *cp1,
100: *cp2;
101: {
102: while (cp1 <= cp2)
103: *cp1++ = ' ';
104: }
105:
106: #if !(defined(IBMPC) || defined(MAC))
107: # define sputc(c) ((*cursor != (char) (c)) ? dosputc((c)) : (cursor++, i_col++))
108: #endif /* (defined(IBMPC) || defined(MAC)) */
109:
110: #ifdef IBMPC
111: int force = 0;
112: # define sputc(c) dosputc((c))
113: #endif /* IBMPC */
114:
115: #ifdef MAC
116: # define sputc(c) bufputc((c)) /* line buffered for mac display */
117: #endif /* MAC */
118:
119: #define soutputc(c) { if (--n <= 0) break; else sputc((c)); }
120:
121: void
122: cl_eol()
123: {
124: if (cursor > cursend)
125: return;
126:
127: if (cursor < Curline->s_length) {
128: #if !(defined(IBMPC) || defined(MAC))
129: if (CE) {
130: #endif /* (defined(IBMPC) || defined(MAC)) */
131: Placur(i_line, i_col);
132: #ifdef TERMCAP
133: putpad(CE, 1);
134: #else
135: clr_eoln();
136: #endif /* TERMCAP */
137: clrline(cursor, Curline->s_length);
138: #if !(defined(IBMPC) || defined(MAC))
139: } else {
140: /* Ugh. The slow way for dumb terminals. */
141: register char *savecp = cursor;
142:
143: while (cursor <= Curline->s_length)
144: sputc(' ');
145: cursor = savecp;
146: }
147: #endif /* (defined(IBMPC) || defined(MAC)) */
148: Curline->s_length = cursor;
149: }
150: }
151:
152: void
153: cl_scr(doit)
154: int doit;
155: {
156: register int i;
157: register struct screenline *sp = Screen;
158:
159: for (i = 0; i < LI; i++, sp++) {
160: clrline(sp->s_line, sp->s_length);
161: sp->s_length = sp->s_line;
162: PhysScreen[i].s_id = 0;
163: }
164: if (doit) {
165: #ifdef TERMCAP
166: putpad(CL, LI);
167: #else
168: clr_page();
169: #endif /* TERMCAP */
170: CapCol = CapLine = 0;
171: UpdMesg = YES;
172: }
173: }
174:
175: /* Output one character (if necessary) at the current position */
176:
177: #ifndef MAC
178: int /* only for lints sake */
179: dosputc(c)
180: register int c;
181: {
182: #ifndef IBMPC
183: if (*cursor != c) {
184: # ifdef ID_CHAR
185: if (IN_INSmode)
186: INSmode(0);
187: # endif
188: #else /* IBMPC */
189: if ((force) || (*cursor != c)) {
190: #endif /* IBMPC */
191: if (i_line != CapLine || i_col != CapCol)
192: Placur(i_line, i_col);
193: #ifndef IBMPC
194: if (UL && (c & CHARMASK) == '_' && (*cursor & CHARMASK) != ' ')
195: putstr(" \b"); /* Erase so '_' looks right. */
196: #endif /* IBMPC */
197: *cursor++ = c;
198: #ifndef IBMPC
199: jputchar(c & CHARMASK);
200: #else /* IBMPC */
201: normfun((char) c);
202: #endif /* IBMPC */
203: AbortCnt -= 1;
204: CapCol += 1;
205: i_col += 1;
206: } else {
207: cursor += 1;
208: i_col += 1;
209: }
210: return 0; /* useless result */
211: }
212: #else /* MAC */
213:
214: /* Character output to bit-mapped screen is very expensive. It makes
215: much more sense to write the entire line at once. So, we print all
216: the characters, whether already there or not, once the line is
217: complete. */
218:
219: #define BUFFLUSH (char) 0
220: #define BUFSTART (char) 1
221:
222: bufputc(c)
223: register char c;
224: {
225: static char buf[256];
226: static int len = 0;
227:
228: if(c == BUFSTART) {
229: /* if (i_line != CapLine || i_col != CapCol)*/
230: NPlacur(i_line, i_col);
231: len = 0;
232: return;
233: }
234: if(c == BUFFLUSH) {
235: buf[0] = (unsigned char) len;
236: writechr(buf);
237: len = 0;
238: }
239: else {
240: if(len > 255) return;
241: *cursor++ = c;
242: if(c == '0') buf[++len] = 0xAF; /* slashed zero */
243: else buf[++len] = c;
244: CapCol++;
245: i_col++;
246: }
247: return;
248: }
249: #endif /* MAC */
250:
251: /* Write `line' at the current position of `cursor'. Stop when we
252: reach the end of the screen. Aborts if there is a character
253: waiting. */
254:
255: #ifdef MAC /* This was getting too complicated with ifdefs ... */
256: int
257: swrite(line, inversep, abortable)
258: register char *line;
259: register int abortable;
260: {
261: register int c;
262: int col = i_col,
263: aborted = 0;
264: register int n = cursend - cursor;
265:
266: if (n <= 0)
267: return 1;
268: sputc(BUFSTART); /* Okay, because no interruption possible */
269:
270: while (c = *line++) {
271: if (abortable && AbortCnt < 0) {
272: AbortCnt = BufSize;
273: if (InputPending = charp()) {
274: aborted = 1;
275: break;
276: }
277: }
278: if (c == '\t') {
279: int nchars;
280:
281: nchars = (tabstop - (col % tabstop));
282: col += nchars;
283:
284: while (nchars--)
285: soutputc(' ');
286: if (n <= 0)
287: break;
288: } else if (isctrl(c)) {
289: soutputc('^');
290: c = ((c == '\177') ? '?' : c + '@');
291: soutputc(c);
292: col += 2;
293: } else {
294: soutputc(c);
295: col += 1;
296: }
297: }
298: if (n <= 0) {
299: if ((*line == '\0') && (c != '\t') && !isctrl(c))
300: sputc(c);
301: sputc('!');
302: }
303: if (cursor > Curline->s_length)
304: Curline->s_length = cursor;
305: sputc(BUFFLUSH);
306: return !aborted;
307: }
308:
309: #else /* MAC */
310:
311: int
312: swrite(line, inversep, abortable)
313: register char *line;
314: int inversep;
315: register int abortable;
316: {
317: register int c;
318: int col = i_col,
319: aborted = 0;
320: register int n = cursend - cursor;
321: #ifndef IBMPC
322: int or_byte = inversep ? 0200 : 0,
323: thebyte;
324: #else
325: int thebyte;
326: #endif /* IBMPC */
327:
328: #ifdef IBMPC
329: force = inversep? 1: 0; /* to force a redraw of the modeline */
330: #endif /* IBMPC */
331:
332: if (n <= 0)
333: return 1;
334: while ((c = *line++) != '\0') {
335: if (abortable && AbortCnt < 0) {
336: AbortCnt = BufSize;
337: if ((InputPending = charp()) != '\0') {
338: aborted = 1;
339: break;
340: }
341: }
342: if (c == '\t') {
343: int nchars;
344:
345: nchars = (tabstop - (col % tabstop));
346: col += nchars;
347:
348: #ifndef IBMPC
349: thebyte = (' ' | or_byte);
350: #endif /* IBMPC */
351: while (nchars--)
352: #ifndef IBMPC
353: soutputc(thebyte);
354: #else /* IBMPC */
355: soutputc(' ');
356: #endif /* IBMPC */
357: if (n <= 0)
358: break;
359: } else if (isctrl(c)) {
360: #ifndef IBMPC
361: thebyte = ('^' | or_byte);
362: soutputc(thebyte);
363: thebyte = (((c == '\177') ? '?' : c + '@') | or_byte);
364: soutputc(thebyte);
365: #else /* IBMPC */
366: soutputc('^');
367: c = ((c == '\177') ? '?' : c + '@');
368: soutputc(c);
369: #endif /* IBMPC */
370: col += 2;
371: #ifdef TERMCAP
372: } else if (HZ && c == '~') {
373: thebyte = ('`' | or_byte);
374: soutputc(thebyte);
375: col += 1;
376: #endif
377: } else {
378: #ifndef IBMPC
379: thebyte = (c | or_byte);
380: soutputc(thebyte);
381: #else /* IBMPC */
382: if (c == 255) c = 1;
383: if (c == ' ' && inversep) c = 255;
384: soutputc(c);
385: #endif /* IBMPC */
386: col += 1;
387: }
388: }
389: if (n <= 0) {
390: if ((*line == '\0') && (c != '\t') && !isctrl(c))
391: #ifndef IBMPC
392: sputc(c|or_byte);
393: #else /* IBMPC */
394: sputc(c);
395: #endif /* IBMPC */
396: else
397: #ifndef IBMPC
398: sputc('!'|or_byte);
399: #else /* IBMPC */
400: sputc('!');
401: #endif /* IBMPC */
402: }
403: if (cursor > Curline->s_length)
404: Curline->s_length = cursor;
405: #ifdef IBMPC
406: force = 0;
407: #endif
408: return !aborted;
409: }
410: #endif /* MAC */
411:
412: /* This is for writing a buffer line to the screen. This is to
413: minimize the amount of copying from one buffer to another buffer.
414: This gets the info directly from the disk buffers. */
415:
416: int
417: BufSwrite(linenum)
418: int linenum;
419: {
420: register int n = cursend - cursor,
421: col = 0,
422: c = -1;
423: register char *bp;
424: int StartCol = DesiredScreen[linenum].s_offset,
425: visspace = DesiredScreen[linenum].s_window->w_flags & W_VISSPACE,
426: aborted = 0;
427:
428: bp = lcontents(DesiredScreen[linenum].s_lp);
429: if (*bp) for (;;) {
430: if (col >= StartCol) {
431: DesiredScreen[linenum].s_offset = col;
432: break;
433: }
434:
435: c = *bp++ & CHARMASK;
436: if (c == '\0')
437: break;
438: if (c == '\t')
439: col += (tabstop - (col % tabstop));
440: else if (isctrl(c))
441: col += 2;
442: else
443: col += 1;
444: }
445: #ifdef MAC
446: sputc(BUFSTART); /* Okay because we can't be interrupted */
447: #endif
448:
449: if (c != '\0') while ((c = *bp++) != '\0') {
450: if (AbortCnt < 0) {
451: AbortCnt = BufSize;
452: if ((InputPending = charp()) != '\0') {
453: aborted = 1;
454: break;
455: }
456: }
457: if (c == '\t') {
458: int nchars = (tabstop - (col % tabstop));
459:
460: col += nchars;
461: if (visspace) {
462: soutputc('>');
463: nchars -= 1;
464: }
465: while (--nchars >= 0)
466: soutputc(' ');
467: if (n <= 0)
468: break;
469: } else if (isctrl(c)) {
470: soutputc('^');
471: soutputc((c == '\177') ? '?' : c + '@');
472: col += 2;
473: #ifdef TERMCAP
474: } else if (HZ && c == '~') {
475: soutputc('`');
476: col += 1;
477: #endif
478: } else {
479: if (c == ' ' && visspace)
480: c = '_';
481: #ifdef IBMPC
482: if (c == 255)
483: c = 1;
484: #endif /* IBMPC */
485: soutputc(c);
486: col += 1;
487: }
488: }
489: if (n <= 0) {
490: if ((*bp == '\0') && (c != '\t') && !isctrl(c))
491: sputc(c);
492: else
493: sputc('!');
494: }
495: if (cursor > Curline->s_length)
496: Curline->s_length = cursor;
497: #ifdef MAC
498: sputc(BUFFLUSH);
499: #endif
500: return !aborted; /* Didn't abort */
501: }
502:
503: void
504: i_set(nline, ncol)
505: register int nline,
506: ncol;
507: {
508: Curline = &Screen[nline];
509: cursor = Curline->s_line + ncol;
510: cursend = &Curline->s_line[CO - 1];
511: i_line = nline;
512: i_col = ncol;
513: }
514:
515: #if !(defined(MAC) || defined(IBMPC))
516: void
517: SO_on()
518: {
519: /* If there are magic cookies, then WHERE the SO string is
520: printed decides where the SO actually starts on the screen.
521: So it's important to make sure the cursor is positioned there
522: anyway. I think this is right. */
523: if (SG != 0) {
524: Placur(i_line, i_col);
525: i_col += SG;
526: CapCol += SG;
527: }
528: putpad(SO, 1);
529: }
530:
531: void
532: SO_off()
533: {
534: /* see comment in SO_on() */
535: if (SG != 0) {
536: Placur(i_line, i_col);
537: i_col += SG;
538: CapCol += SG;
539: }
540: putpad(SE, 1);
541: }
542: #endif
543:
544: /* Insert `num' lines a top, but leave all the lines BELOW `bottom'
545: alone (at least they won't look any different when we are done).
546: This changes the screen array AND does the physical changes. */
547:
548: void
549: v_ins_line(num, top, bottom)
550: int num,
551: top,
552: bottom;
553: {
554: register int i;
555:
556: /* Save the screen pointers. */
557:
558: for(i = 0; i < num && top + i <= bottom; i++)
559: Savelines[i] = Screen[bottom - i];
560:
561: /* Num number of bottom lines will be lost.
562: Copy everything down num number of times. */
563:
564: for (i = bottom; i > top && i-num >= 0; i--)
565: Screen[i] = Screen[i - num];
566:
567: /* Restore the saved ones, making them blank. */
568:
569: for (i = 0; i < num; i++) {
570: Screen[top + i] = Savelines[i];
571: clrline(Screen[top + i].s_line, Screen[top + i].s_length);
572: Screen[top + i].s_length = Screen[top + i].s_line;
573: }
574:
575: #if !(defined(IBMPC) || defined(MAC))
576: (*TTins_line)(top, bottom, num);
577: #endif
578:
579: #ifdef MAC
580: i_lines(top, bottom, num);
581: #endif
582:
583: #ifdef IBMPC
584: scr_win((int) -num, (unsigned char) top, 0, (unsigned char) bottom, CHPL-1);
585: #endif
586: }
587:
588: /* Delete `num' lines starting at `top' leaving the lines below `bottom'
589: alone. This updates the internal image as well as the physical image. */
590:
591: void
592: v_del_line(num, top, bottom)
593: int num,
594: top,
595: bottom;
596: {
597: register int i,
598: bot;
599:
600: bot = bottom;
601:
602: /* Save the lost lines. */
603:
604: for (i = 0; i < num && top + i <= bottom; i++)
605: Savelines[i] = Screen[top + i];
606:
607: /* Copy everything up num number of lines. */
608:
609: for (i = top; num + i <= bottom; i++)
610: Screen[i] = Screen[i + num];
611:
612: /* Restore the lost ones, clearing them. */
613:
614: for (i = 0; i < num; i++) {
615: Screen[bottom - i] = Savelines[i];
616: clrline(Screen[bot].s_line, Screen[bot].s_length);
617: Screen[bot].s_length = Screen[bot].s_line;
618: bot -= 1;
619: }
620:
621: #if !(defined(IBMPC) || defined(MAC))
622: (*TTdel_line)(top, bottom, num);
623: #endif
624:
625: #ifdef MAC
626: d_lines(top, bottom, num);
627: #endif
628:
629: #ifdef IBMPC
630: scr_win(num, (unsigned char) top, 0, (unsigned char) bottom, CHPL-1);
631: #endif
632:
633: }
634:
635: #if !(defined(MAC) || defined(IBMPC)) /* remainder of this file */
636:
637: /* The cursor optimization happens here. You may decide that this
638: is going too far with cursor optimization, or perhaps it should
639: limit the amount of checking to when the output speed is slow.
640: What ever turns you on ... */
641:
642: struct cursaddr {
643: int cm_numchars;
644: void (*cm_proc) ();
645: };
646:
647: private char *Cmstr;
648: private struct cursaddr *HorMin,
649: *VertMin,
650: *DirectMin;
651:
652: private void
653: GENi_lines proto((int, int, int)),
654: GENd_lines proto((int, int, int)),
655: ForMotion proto((int)),
656: ForTab proto((int)),
657: BackMotion proto((int)),
658: RetTab proto((int)),
659: DownMotion proto((int)),
660: UpMotion proto((int)),
661: GoDirect proto((int, int)),
662: HomeGo proto((int, int)),
663: BottomUp proto((int, int));
664:
665:
666: private struct cursaddr WarpHor[] = {
667: 0, ForMotion,
668: 0, ForTab,
669: 0, BackMotion,
670: 0, RetTab
671: };
672:
673: private struct cursaddr WarpVert[] = {
674: 0, DownMotion,
675: 0, UpMotion
676: };
677:
678: private struct cursaddr WarpDirect[] = {
679: 0, GoDirect,
680: 0, HomeGo,
681: 0, BottomUp
682: };
683:
684: #undef FORWARD
685: #define FORWARD 0 /* Move forward */
686: #define FORTAB 1 /* Forward using tabs */
687: #undef BACKWARD
688: #define BACKWARD 2 /* Move backward */
689: #define RETFORWARD 3 /* Beginning of line and then tabs */
690: #define NUMHOR 4
691:
692: #define DOWN 0 /* Move down */
693: #define UPMOVE 1 /* Move up */
694: #define NUMVERT 2
695:
696: #define DIRECT 0 /* Using CM */
697: #define HOME 1 /* HOME */
698: #define LOWER 2 /* Lower Line */
699: #define NUMDIRECT 3
700:
701: #define home() Placur(0, 0)
702: #define LowLine() { putpad(LL, 1); CapLine = ILI; CapCol = 0; }
703: #define PrintHo() { putpad(HO, 1); CapLine = CapCol = 0; }
704:
705: int phystab = 8;
706:
707: private void
708: GoDirect(line, col)
709: register int line,
710: col;
711: {
712: putpad(Cmstr, 1);
713: CapLine = line;
714: CapCol = col;
715: }
716:
717: private void
718: RetTab(col)
719: register int col;
720: {
721: jputchar('\r');
722: CapCol = 0;
723: ForTab(col);
724: }
725:
726: private void
727: HomeGo(line, col)
728: int line,
729: col;
730: {
731: PrintHo();
732: DownMotion(line);
733: ForTab(col);
734: }
735:
736: private void
737: BottomUp(line, col)
738: register int line,
739: col;
740: {
741: LowLine();
742: UpMotion(line);
743: ForTab(col);
744: }
745:
746: /* Tries to move forward using tabs (if possible). It tabs to the
747: closest tabstop which means it may go past 'destcol' and backspace
748: to it. */
749:
750: private void
751: ForTab(destcol)
752: int destcol;
753: {
754: register int tabgoal,
755: ntabs,
756: tabstp = phystab;
757:
758: if (TABS && (tabstp > 0)) {
759: tabgoal = destcol + (tabstp / 2);
760: tabgoal -= (tabgoal % tabstp);
761:
762: /* Don't tab to last place or else it is likely to screw up. */
763: if (tabgoal >= CO)
764: tabgoal -= tabstp;
765:
766: ntabs = (tabgoal / tabstp) - (CapCol / tabstp);
767: while (--ntabs >= 0)
768: jputchar('\t');
769: CapCol = tabgoal;
770: }
771: if (CapCol > destcol)
772: BackMotion(destcol);
773: else if (CapCol < destcol)
774: ForMotion(destcol);
775: }
776:
777: private void
778: ForMotion(destcol)
779: register int destcol;
780: {
781: register int nchars = destcol - CapCol;
782: register char *cp = &Screen[CapLine].s_line[CapCol];
783:
784: while (--nchars >= 0)
785: jputchar(*cp++ & CHARMASK);
786: CapCol = destcol;
787: }
788:
789: private void
790: BackMotion(destcol)
791: register int destcol;
792: {
793: register int nchars = CapCol - destcol;
794:
795: if (BC)
796: while (--nchars >= 0)
797: putpad(BC, 1);
798: else
799: while (--nchars >= 0)
800: jputchar('\b');
801: CapCol = destcol;
802: }
803:
804: private void
805: DownMotion(destline)
806: register int destline;
807: {
808: register int nlines = destline - CapLine;
809:
810: while (--nlines >= 0)
811: putpad(DO, 1);
812: CapLine = destline;
813: }
814:
815: private void
816: UpMotion(destline)
817: register int destline;
818: {
819: register int nchars = CapLine - destline;
820:
821: while (--nchars >= 0)
822: putpad(UP, 1);
823: CapLine = destline;
824: }
825:
826: #ifdef ID_CHAR
827: static int EIlen;
828: #endif
829:
830: #ifndef IBMPC
831:
832: void
833: InitCM()
834: {
835: HOlen = HO ? strlen(HO) : 1000;
836: LLlen = LL ? strlen(LL) : 1000;
837: UPlen = UP ? strlen(UP) : 1000;
838: #ifdef ID_CHAR
839: if (EI)
840: EIlen = strlen(EI);
841: #endif
842: }
843:
844: private int ForNum proto((int from, int to));
845:
846: void
847: Placur(line, col)
848: int line,
849: col;
850: {
851: int dline, /* Number of lines to move */
852: dcol; /* Number of columns to move */
853: register int best,
854: i;
855: register struct cursaddr *cp;
856: int xtracost = 0; /* Misc addition to cost. */
857:
858: #define CursMin(which,addrs,max) { \
859: for (best = 0, cp = &(addrs)[1], i = 1; i < (max); i++, cp++) \
860: if (cp->cm_numchars < (addrs)[best].cm_numchars) \
861: best = i; \
862: (which) = &(addrs)[best]; \
863: }
864:
865: if (line == CapLine && col == CapCol)
866: return; /* We are already there. */
867:
868: dline = line - CapLine;
869: dcol = col - CapCol;
870: #ifdef ID_CHAR
871: if (IN_INSmode && MI)
872: xtracost = EIlen + IMlen;
873: /* If we're already in insert mode, it is likely that we will
874: want to be in insert mode again, after the insert. */
875: #endif
876:
877: /* Number of characters to move horizontally for each case.
878: 1: Just move forward by typing the right character on the screen.
879: 2: Print the correct number of back spaces.
880: 3: Try tabbing to the correct place.
881: 4: Try going to the beginning of the line, and then tab. */
882:
883: if (dcol == 1 || dcol == 0) { /* Most common case. */
884: HorMin = &WarpHor[FORWARD];
885: HorMin->cm_numchars = dcol + xtracost;
886: } else {
887: WarpHor[FORWARD].cm_numchars = dcol >= 0 ? dcol + xtracost : 1000;
888: WarpHor[BACKWARD].cm_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
889: WarpHor[FORTAB].cm_numchars = dcol >= 0 && TABS ?
890: ForNum(CapCol, col) + xtracost : 1000;
891: WarpHor[RETFORWARD].cm_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
892:
893: /* Which is the shortest of the bunch */
894:
895: CursMin(HorMin, WarpHor, NUMHOR);
896: }
897:
898: /* Moving vertically is more simple. */
899:
900: WarpVert[DOWN].cm_numchars = dline >= 0 ? dline : 1000;
901: WarpVert[UPMOVE].cm_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
902:
903: /* Which of these is simpler */
904: CursMin(VertMin, WarpVert, NUMVERT);
905:
906: /* Homing first and lowering first are considered
907: direct motions.
908: Homing first's total is the sum of the cost of homing
909: and the sum of tabbing (if possible) to the right. */
910:
911: if (VertMin->cm_numchars + HorMin->cm_numchars <= 3) {
912: DirectMin = &WarpDirect[DIRECT]; /* A dummy ... */
913: DirectMin->cm_numchars = 100;
914: } else {
915: WarpDirect[DIRECT].cm_numchars = CM ?
916: strlen(Cmstr = tgoto(CM, col, line)) : 1000;
917: WarpDirect[HOME].cm_numchars = HOlen + line +
918: WarpHor[RETFORWARD].cm_numchars;
919: WarpDirect[LOWER].cm_numchars = LLlen + ((ILI - line) * UPlen) +
920: WarpHor[RETFORWARD].cm_numchars;
921: CursMin(DirectMin, WarpDirect, NUMDIRECT);
922: }
923:
924: if (HorMin->cm_numchars + VertMin->cm_numchars < DirectMin->cm_numchars) {
925: if (line != CapLine)
926: (*VertMin->cm_proc)(line);
927: if (col != CapCol) {
928: #ifdef ID_CHAR
929: if (IN_INSmode) /* We may use real characters ... */
930: INSmode(0);
931: #endif
932: (*HorMin->cm_proc)(col);
933: }
934: } else {
935: #ifdef ID_CHAR
936: if (IN_INSmode && !MI)
937: INSmode(0);
938: #endif
939: (*DirectMin->cm_proc)(line, col);
940: }
941: }
942:
943: #endif /* IBMPC */
944:
945: #define abs(x) ((x) >= 0 ? (x) : -(x))
946:
947: private int
948: ForNum(from, to)
949: register int from;
950: int to;
951: {
952: register int tabgoal,
953: tabstp = phystab;
954: int numchars = 0;
955:
956: if (from >= to)
957: return from - to;
958: if (TABS && (tabstp > 0)) {
959: tabgoal = to + (tabstp / 2);
960: tabgoal -= (tabgoal % tabstp);
961: if (tabgoal >= CO)
962: tabgoal -= tabstp;
963: numchars = (tabgoal / tabstop) - (from / tabstp);
964: from = tabgoal;
965: }
966: return numchars + abs(from - to);
967: }
968:
969: #ifdef WIRED_TERMS
970:
971: private void
972: BGi_lines(top, bottom, num)
973: int top,
974: bottom,
975: num;
976: {
977: writef("\033[%d;%dr\033[%dL\033[r", top + 1, bottom + 1, num);
978: CapCol = CapLine = 0;
979: }
980:
981: private void
982: SUNi_lines(top, bottom, num)
983: int top,
984: bottom,
985: num;
986: {
987: Placur(bottom - num + 1, 0);
988: writef("\033[%dM", num);
989: Placur(top, 0);
990: writef("\033[%dL", num);
991: }
992:
993: private void
994: C100i_lines(top, bottom, num)
995: int top,
996: bottom,
997: num;
998: {
999: if (num <= 1) {
1000: GENi_lines(top, bottom, num);
1001: return;
1002: }
1003: writef("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO);
1004: CapLine = CapCol = 0;
1005: Placur(top, 0);
1006: while (num--)
1007: putpad(AL, ILI - CapLine);
1008: writef("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO);
1009: CapLine = CapCol = 0;
1010: }
1011:
1012: #endif /* WIRED_TERMS */
1013:
1014: private void
1015: GENi_lines(top, bottom, num)
1016: int top,
1017: bottom,
1018: num;
1019: {
1020: register int i;
1021:
1022: if (CS) {
1023: putpad(tgoto(CS, bottom, top), 1);
1024: CapCol = CapLine = 0;
1025: Placur(top, 0);
1026: for (i = 0; i < num; i++)
1027: putpad(SR, bottom - top);
1028: putpad(tgoto(CS, ILI, 0), 1);
1029: CapCol = CapLine = 0;
1030: } else {
1031: Placur(bottom - num + 1, 0);
1032: if (M_DL && (num > 1)) {
1033: putargpad(M_DL, num, ILI - CapLine);
1034: } else {
1035: for (i = 0; i < num; i++)
1036: putpad(DL, ILI - CapLine);
1037: }
1038: Placur(top, 0);
1039: if (M_AL && (num > 1)) {
1040: putargpad(M_AL, num, ILI - CapLine);
1041: } else {
1042: for (i = 0; i < num; i++)
1043: putpad(AL, ILI - CapLine);
1044: }
1045: }
1046: }
1047:
1048: #ifdef WIRED_TERMS
1049:
1050: private void
1051: BGd_lines(top, bottom, num)
1052: int top,
1053: bottom,
1054: num;
1055: {
1056: writef("\033[%d;%dr\033[%dM\033[r", top + 1, bottom + 1, num);
1057: CapCol = CapLine = 0;
1058: }
1059:
1060: private void
1061: SUNd_lines(top, bottom, num)
1062: int top,
1063: bottom,
1064: num;
1065: {
1066: Placur(top, 0);
1067: writef("\033[%dM", num);
1068: Placur(bottom + 1 - num, 0);
1069: writef("\033[%dL", num);
1070: }
1071:
1072: private void
1073: C100d_lines(top, bottom, num)
1074: int top,
1075: bottom,
1076: num;
1077: {
1078: if (num <= 1) {
1079: GENd_lines(top, bottom, num);
1080: return;
1081: }
1082: writef("\033v%c%c%c%c", ' ', ' ', ' ' + bottom + 1, ' ' + CO);
1083: CapLine = CapCol = 0;
1084: Placur(top, 0);
1085: while (num--)
1086: putpad(DL, ILI - CapLine);
1087: writef("\033v%c%c%c%c", ' ', ' ', ' ' + LI, ' ' + CO);
1088: CapLine = CapCol = 0;
1089: }
1090:
1091: #endif /* WIRED_TERMS */
1092:
1093: private void
1094: GENd_lines(top, bottom, num)
1095: int top,
1096: bottom,
1097: num;
1098: {
1099: register int i;
1100:
1101: if (CS) {
1102: putpad(tgoto(CS, bottom, top), 1);
1103: CapCol = CapLine = 0;
1104: Placur(bottom, 0);
1105: for (i = 0; i < num; i++)
1106: putpad(SF, bottom - top);
1107: putpad(tgoto(CS, ILI, 0), 1);
1108: CapCol = CapLine = 0;
1109: } else {
1110: Placur(top, 0);
1111: if (M_DL && (num > 1)) {
1112: putargpad(M_DL, num, ILI - top);
1113: } else {
1114: for (i = 0; i < num; i++)
1115: putpad(DL, ILI - top);
1116: }
1117: Placur(bottom + 1 - num, 0);
1118: if (M_AL && (num > 1)) {
1119: putargpad(M_AL, num, ILI - CapLine);
1120: } else {
1121: for (i = 0; i < num; i++)
1122: putpad(AL, ILI - CapLine);
1123: }
1124: }
1125: }
1126:
1127: private const struct ID_lookup {
1128: char *ID_name;
1129: void (*I_proc) proto((int, int, int)); /* proc to insert lines */
1130: void (*D_proc) proto((int, int, int)); /* proc to delete lines */
1131: } ID_trms[] = {
1132: "generic", GENi_lines, GENd_lines, /* This should stay here */
1133: #ifdef WIRED_TERMS
1134: "sun", SUNi_lines, SUNd_lines,
1135: "bg", BGi_lines, BGd_lines,
1136: "c1", C100i_lines, C100d_lines,
1137: #endif /* WIRED_TERMS */
1138: 0, 0, 0
1139: };
1140:
1141: void
1142: IDline_setup(tname)
1143: char *tname;
1144: {
1145: register const struct ID_lookup *idp;
1146:
1147: for (idp = &ID_trms[1]; idp->ID_name; idp++)
1148: if (strncmp(idp->ID_name, tname, strlen(idp->ID_name)) == 0)
1149: break;
1150: if (idp->ID_name == 0)
1151: idp = &ID_trms[0];
1152: #ifndef IBMPC
1153: TTins_line = idp->I_proc;
1154: TTdel_line = idp->D_proc;
1155: #endif
1156: }
1157:
1158: #endif /* MAC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.