![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ptofchar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / src / mux / term / frame|
Return to ptofchar.c CVS log | Up to [Research Unix] / researchv9 / jerq / src / mux / term / frame |
1.1 root 1: #include <jerq.h>
2: #include <layer.h>
3: #include <queue.h>
4: #include <jerqproc.h>
5: #include "frame.h"
6: /*
7: * Screen position of cn'th character in frame t.
8: * Returns last visible point if cn is offscreen.
9: */
10: #ifdef SAFE
11: Point
12: ptofchar(t, cn)
13: register Frame *t;
14: register cn;
15: {
16: frameop(t, opnull, t->rect.origin, t->str.s, cn);
17: return endpoint;
18: }
19: #else
20: Point
21: ptofchar(t, cn)
22: register Frame *t;
23: register cn;
24: {
25: register Nchar *np;
26: register l, c; /* line number, char number */
27: /* nlines-1 because we must do the frameop */
28: for(l=0,c=0,np=t->cpl; l<t->nlines-1 && c+*np<cn; l++)
29: c+= *np++;
30: frameop(t, opnull, startline(t, l), t->str.s+c, cn-c);
31: return endpoint;
32: }
33: #endif
34: /*
35: * Index of character at position pt in frame t.
36: * Returns (efficiently!) number of chars in frame if pt is off end.
37: */
38: int
39: charofpt(t, pt)
40: register Frame *t;
41: Point pt;
42: {
43: register l, c, starty; /* line, char posn */
44: register i, y=pt.y;
45: register Nchar *np;
46: register char *s;
47: pt.y-=(y-t->rect.origin.y)%newlnsz; /* on a line bdry */
48: y=pt.y-t->rect.origin.y;
49: if((y/=newlnsz) > t->nlines) /* y is line containing pt */
50: y=t->nlines; /* not nlines-1 because of upcoming if */
51: for(c=0,l=0,np=t->cpl; l<y; l++)
52: c+= *np++;
53: if(y < t->nlines){
54: endpoint=startline(t, y);
55: starty=endpoint.y;
56: s=t->str.s+c;
57: for(i=0; i<*np; i++,c++){
58: frameop(t, opnull, endpoint, s++, 1/* sigh */);
59: if(endpoint.x>pt.x || endpoint.y!=starty)
60: break;
61: }
62: }
63: return c;
64: }
65: /*
66: * Point at start of line n in frame t
67: */
68: Point
69: startline(t, n)
70: register Frame *t;
71: register n;
72: {
73: Point pt;
74: pt=t->rect.origin;
75: pt.y+=n*newlnsz;
76: return pt;
77: }
78: /*
79: * Calculate and set the number of characters per line in lines
80: * first through last, inclusive, in frame t.
81: */
82: setcpl(t, first, last)
83: register Frame *t;
84: {
85: register Nchar *np;
86: register l, c; /* lines, characters */
87:
88: if(last>=t->nlines)
89: last=t->nlines-1;
90: for(c=0,l=0,np=t->cpl; l<first; l++)
91: c+= *np++;
92: /* c now tracks number of chars before line of interest */
93: while(l<=last && c<t->str.n)
94: c+= *np++=cpl(t, c, startline(t, l++));
95: while(l++ <= last)
96: *np++=0;
97: }
98: /* Frameop operator to calculate number of chars in a line */
99: static nc, lasty, wrapped;
100: /*ARGSUSED*/
101: void
102: opcpl(t, p, q, cp, n)
103: Frame *t;
104: Point p, q;
105: char *cp;
106: int n;
107: {
108: if(p.y==lasty)
109: nc+=n;
110: else
111: wrapped=TRUE;
112: }
113: cpl(t, posn, pt)
114: register Frame *t;
115: int posn;
116: Point pt;
117: {
118: register ntotry=(t->rect.corner.x-t->rect.origin.x)/cwidth('1');
119: /*
120: * If there are no control chars, you can't get more than
121: * (linewidth/charwidth) chars on a line, so to be safe we
122: * keep trying if the frameop didn't reach the end of the line.
123: */
124: lasty=pt.y;
125: do{
126: if((ntotry+=7) > t->str.n-posn) /* 7 is arbitrary */
127: ntotry=t->str.n-posn;
128: nc=0;
129: wrapped=FALSE;
130: frameop(t, opcpl, pt, t->str.s+posn, ntotry);
131: }while(!wrapped && complete && posn+ntotry<t->str.n);
132: return nc;
133: }
134: /*
135: * Scroll first through last entries in the cpl array by n.
136: * n<0 ==> up screen, n>0 ==> down screen. First and last must
137: * be in the correct order in the call, i.e. first>last for n>0,
138: * first<last for n<0.
139: */
140: scrollcpl(t, first, last, n)
141: Frame *t;
142: register first, last, n;
143: {
144: register i;
145: register Nchar *np= &t->cpl[first];
146: register delta=(n>0)? -1 : 1;
147: if(first>last){
148: i=first;
149: first=last;
150: last=i;
151: }
152: for(i=first; i<=last; i++,np+=delta)
153: np[n]=np[0];
154: }
155: lineno(t, y)
156: register Frame *t;
157: register y;
158: {
159: return (y-t->rect.origin.y)/newlnsz;
160: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.