![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cursor.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / src / lib / sys|
Return to cursor.c CVS log | Up to [Research Unix] / researchv9 / jerq / src / lib / sys |
1.1 root 1: #include <jerq.h>
2: struct Mouse mouse;
3: void nap();
4: static short c_ul[]={
5: 0xFF80, 0xFE00, 0xF800, 0xFC00,
6: 0xFE00, 0xDF00, 0xCF80, 0x87C0,
7: 0x83E0, 0x01F0, 0x00F8, 0x007C,
8: 0x003E, 0x001F, 0x000E, 0x0004,
9: };
10: static short c_ll[]={
11: 0x0004, 0x000E, 0x001F, 0x003E,
12: 0x007C, 0x00F8, 0x01F0, 0x83E0,
13: 0x87C0, 0xCF80, 0xDF00, 0xFE00,
14: 0xFC00, 0xF800, 0xFE00, 0xFF80,
15: };
16: static short c_ur[]={
17: 0x01FF, 0x007F, 0x001F, 0x003F,
18: 0x007F, 0x00FB, 0x01F3, 0x03E1,
19: 0x07C1, 0x0F80, 0x1F00, 0x3E00,
20: 0x7C00, 0xF800, 0x7000, 0x2000,
21: };
22: static short c_lr[]={
23: 0x2000, 0x7000, 0xF800, 0x7C00,
24: 0x3E00, 0x1F00, 0x0F80, 0x07C1,
25: 0x03E1, 0x01F3, 0x00FB, 0x007F,
26: 0x003F, 0x001F, 0x007F, 0x01FF,
27: };
28: static setxy(), flipcursor();
29: struct curtab{
30: short *map;
31: short dx;
32: short dy;
33: }stdcurtab[4]={ /* 4 quadrants */
34: c_ur, -16, 0,
35: c_ul, 0, 0,
36: c_lr, -16, -16,
37: c_ll, 0, -16,
38: }, usercurtab[4];
39: struct curtab *curtabp;
40: struct cursor{
41: unsigned x, y;
42: unsigned oldx, oldy;
43: char quad, oldquad;
44: short inhibit;
45: short up;
46: }cursor;
47: static int ud, lr;
48: #define QRL_MASK 01
49: #define QUD_MASK 02
50: #define QRIGHT 0
51: #define QLEFT 01
52: #define QUP 0
53: #define QDOWN 02
54: #define QLEFT_MARGIN XMAX/3
55: #define QRIGHT_MARGIN XMAX*2/3
56: #define QUP_MARGIN YMAX/3
57: #define QDOWN_MARGIN YMAX*2/3
58:
59: newquad(x, y, quad)
60: register x, y, quad;
61: {
62: ud=quad&QUD_MASK;
63: lr=quad&QRL_MASK;
64: if(x < QLEFT_MARGIN)
65: lr=QLEFT;
66: if(x > QRIGHT_MARGIN)
67: lr=QRIGHT;
68: if(y < QUP_MARGIN)
69: ud=QUP;
70: if(y > QDOWN_MARGIN)
71: ud=QDOWN;
72: return ud|lr;
73: }
74: cursinhibit(){
75: register sr=spl1();
76: if(cursor.inhibit++==0 && cursor.up)
77: flipcursor(cursor.x, cursor.y, cursor.quad);
78: splx(sr);
79: }
80: cursallow(){
81: if(cursor.inhibit>0)
82: cursor.inhibit--;
83: }
84: #define MOUSEMAX 2048 /* 1/2 resolution of mouse registers */
85: /*static*/ struct data {
86: int last;
87: int zero;
88: }xdata, ydata;
89: static int
90: update(var, datap, max)
91: register var, max;
92: register struct data *datap;
93: {
94: register d;
95: d=var-datap->last;
96: if(d>MOUSEMAX)
97: datap->zero+=MOUSEMAX*2;
98: else if(d<-MOUSEMAX)
99: datap->zero-=MOUSEMAX*2;
100: datap->last=var;
101: d=var-datap->zero; /* re-use of d */
102: if(d<0){
103: datap->zero=var;
104: d=0;
105: }else if(d>=max){
106: datap->zero=var-max;
107: d=max-1;
108: }
109: return d;
110: }
111: static
112: setxy(){
113: register struct curtab *qp;
114: register x, y, quad;
115: x= *XMOUSE & 0xfff; /* coordinates go the wrong way, so negate */
116: y= -(*YMOUSE & 0xfff);
117: cursor.oldx=cursor.x;
118: cursor.oldy=cursor.y;
119: cursor.oldquad=cursor.quad;
120: x=update(x, &xdata, XMAX);
121: y=update(y, &ydata, YMAX);
122: quad=newquad(x, y, cursor.quad);
123: qp= &curtabp[quad];
124: if(x< -qp->dx)
125: x= -qp->dx;
126: if(x+(16+qp->dx)>=XMAX)
127: x=XMAX-(16+qp->dx)-1;
128: if(y< -qp->dy)
129: y= -qp->dy;
130: if(y+(16+qp->dy)>=YMAX)
131: y=YMAX-(16+qp->dy)-1;
132: if(x==cursor.oldx && y==cursor.oldy && cursor.up)
133: return(0);
134: cursor.x=x;
135: cursor.y=y;
136: cursor.quad=quad;
137: mouse.xy.x=x;
138: mouse.xy.y=y;
139: return(1);
140: }
141: cursset(p)
142: Point p;
143: {
144: xdata.zero=xdata.last-p.x;
145: ydata.zero=ydata.last-p.y;
146: nap(1);
147: }
148: Bitmap cursbm;
149: static
150: flipcursor(x, y, q)
151: {
152: register struct curtab *qp;
153: register s;
154: qp= &curtabp[q];
155: cursbm.base=(Word *) qp->map;
156: cursblt(&display, qp->map, Pt(x+qp->dx, y+qp->dy));
157: /* almost equal to
158: /* bitblt(&cursbm, cursbm.rect, &display,
159: /* Pt(x+qp->dx, y+qp->dy), F_XOR); */
160: cursor.up=1-cursor.up;
161: }
162: short interrupt;
163: cursinit(){
164: curtabp=stdcurtab;
165: cursbm.width=1;
166: cursbm.rect.corner.x=cursbm.rect.corner.y=16;
167: cursor.inhibit = 0;
168: }
169: auto1(){
170: if(setxy() && cursor.inhibit==0){
171: if(cursor.up)
172: flipcursor(cursor.oldx, cursor.oldy, cursor.oldquad);
173: flipcursor(cursor.x, cursor.y, cursor.quad);
174: }
175: interrupt++;
176: }
177: void nap(n){
178: if(n<=0)
179: return;
180: interrupt=0;
181: do; while(interrupt<n);
182: }
183:
184: /* static*/ Texture *old;
185: Texture *
186: cursswitch(p)
187: register Texture *p;
188: {
189: register struct curtab *ctp;
190: register Texture *t=old;
191: old=p;
192: cursinhibit();
193: if(p==0)
194: curtabp=stdcurtab;
195: else{
196: curtabp=usercurtab;
197: for(ctp=usercurtab; ctp<&usercurtab[4]; ctp++){
198: ctp->map=(short *)p;
199: ctp->dx=ctp->dy= -8;
200: }
201: }
202: cursallow();
203: return t;
204: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.