![[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 [Plan 9 NeXT] / lucent / sys / src / 9 / next|
Return to screen.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / next |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "io.h"
7: #include "ureg.h"
8: #include "../port/error.h"
9:
10: #include <libg.h>
11: #include <gnot.h>
12: #include "screen.h"
13:
14: #define MINX 8
15:
16: extern GSubfont defont0;
17: GSubfont *defont;
18:
19: struct{
20: Point pos;
21: int bwid;
22: }out;
23:
24: Lock screenlock;
25:
26: void duartinit(void);
27: int duartacr;
28: int duartimr;
29:
30: void (*kprofp)(ulong);
31:
32: GBitmap gscreen =
33: {
34: (ulong*)DISPLAYRAM, /* BUG */
35: 0,
36: 2*1152/32,
37: 1,
38: { 0, 0, 1120, 832, },
39: { 0, 0, 1120, 832, },
40: 0
41: };
42:
43: void
44: screeninit(void)
45: {
46: void bigcursor(void);
47: bigcursor();
48:
49: defont = &defont0; /* save space; let bitblt do the conversion work */
50: gbitblt(&gscreen, Pt(0, 0), &gscreen, gscreen.r, 0); /**/
51: out.pos.x = MINX;
52: out.pos.y = 0;
53: out.bwid = defont0.info[' '].width;
54: }
55:
56: void
57: screenputs(char *s, int n)
58: {
59: Rune r;
60: int i;
61: char buf[4];
62:
63: if(getsr() & 0x0700){
64: if(!canlock(&screenlock))
65: return; /* don't deadlock trying to print in interrupt */
66: }else
67: lock(&screenlock);
68: while(n > 0){
69: i = chartorune(&r, s);
70: if(i == 0){
71: s++;
72: --n;
73: continue;
74: }
75: memmove(buf, s, i);
76: buf[i] = 0;
77: n -= i;
78: s += i;
79: if(r == '\n'){
80: out.pos.x = MINX;
81: out.pos.y += defont0.height;
82: if(out.pos.y > gscreen.r.max.y-defont0.height)
83: out.pos.y = gscreen.r.min.y;
84: gbitblt(&gscreen, Pt(0, out.pos.y), &gscreen,
85: Rect(0, out.pos.y, gscreen.r.max.x, out.pos.y+2*defont0.height), 0);
86: }else if(r == '\t'){
87: out.pos.x += (8-((out.pos.x-MINX)/out.bwid&7))*out.bwid;
88: if(out.pos.x >= gscreen.r.max.x)
89: screenputs("\n", 1);
90: }else if(r == '\b'){
91: if(out.pos.x >= out.bwid+MINX){
92: out.pos.x -= out.bwid;
93: gsubfstring(&gscreen, out.pos, defont, " ", S);
94: }
95: }else{
96: if(out.pos.x >= gscreen.r.max.x-out.bwid)
97: screenputs("\n", 1);
98: out.pos = gsubfstring(&gscreen, out.pos, defont, buf, S);
99: }
100: }
101: unlock(&screenlock);
102: }
103:
104: #include "keys.h"
105:
106: void
107: kbdstate(int ch)
108: {
109: static int collecting, nk;
110: static uchar kc[5];
111: int c, i;
112:
113: if(ch == 0xff){
114: collecting = 0;
115: return;
116: }
117: if(ch == -1){
118: collecting = 1;
119: nk = 0;
120: return;
121: }
122: if(!collecting){
123: kbdrepeat(1);
124: kbdputc(&kbdq, ch);
125: return;
126: }
127: kc[nk++] = ch;
128: c = latin1(kc, nk);
129: if(c < -1) /* need more keystrokes */
130: return;
131: if(c != -1) /* valid sequence */
132: kbdputc(&kbdq, c);
133: else /* dump characters */
134: for(i=0; i<nk; i++)
135: kbdputc(&kbdq, kc[i]);
136: nk = 0;
137: collecting = 0;
138: }
139:
140: int altcmd; /* state of left alt and command keys */
141:
142: void
143: kbdmouseintr(void)
144: {
145: int c;
146: ulong d;
147: int dx, dy;
148: static int b;
149:
150: if(*(ulong*)MONCSR & (1<<23)){
151: if(*(ulong*)MONCSR & (1<<22)){
152: d = *(ulong*)KBDDATA;
153: if(d & (0xF<<24)){
154: if((d&0x01) == 0)
155: b |= 1;
156: else
157: b &= ~1;
158: if((d&0x100) == 0)
159: b |= mouseshifted ? 2 : 4;
160: else
161: b &= ~6;
162: dx = (d>>1) & 0x7F;
163: dy = (d>>9) & 0x7F;
164: if(dx & 0x40)
165: dx |= ~0x7F;
166: if(dy & 0x40)
167: dy |= ~0x7F;
168: mousetrack(b, 3*-dx, 3*-dy);
169: }else{
170: /* alt key + right mouse button == middle mouse button */
171: if((d&0x2000))
172: altcmd |= 1;
173: else if(!(d&0x2000))
174: altcmd &= ~1;
175: mouseshifted = altcmd & 1;
176: if((d&0x800)) /* left command */
177: altcmd |= 2;
178: else if(!(d&0x800))
179: altcmd &= ~2;
180: if(d & 0x4000){ /* right alt */
181: kbdstate(-1);
182: goto out;
183: }
184: if(d & 0x8000){ /* valid data */
185: if(d & 0x80){ /* up */
186: kbdrepeat(0);
187: goto out;
188: }
189: if(d & 0x100)
190: c = keyc[d&0x7f];
191: else if(d & 0x600)
192: c = keys[d&0x7f];
193: else
194: c = key0[d&0x7F];
195: kbdstate(c);
196: }
197: }
198: }
199: out:
200: if(*(ulong*)MONCSR & (1<<21)){
201: /* keyboard overrun */
202: *(ulong*)MONCSR |= (1<<21);
203: }
204: }
205: if(*(ulong*)MONCSR & (1<<19)){
206: print("kms interrupt\n");
207: if(*(ulong*)MONCSR & (1<<17)){
208: print("kms overrun\n");
209: *(ulong*)MONCSR |= (1<<17);
210: }
211: if(*(ulong*)MONCSR & (1<<18))
212: print("kmsdata %lux\n", *(ulong*)KMSDATA);
213: }
214: }
215:
216:
217: void
218: buzz(int freq, int dur)
219: {
220: USED(freq, dur);
221: }
222:
223: void
224: lights(int mask)
225: {
226: USED(mask);
227: }
228:
229: int
230: screenbits(void)
231: {
232: return 2; /* bits per pixel */
233: }
234:
235: void
236: getcolor(ulong p, ulong *pr, ulong *pg, ulong *pb)
237: {
238: ulong ans;
239:
240: /*
241: * The next says 0 is white (max intensity)
242: */
243: switch(p){
244: case 0: ans = ~0; break;
245: case 1: ans = 0xAAAAAAAA; break;
246: case 2: ans = 0x55555555; break;
247: default: ans = 0; break;
248: }
249: *pr = *pg = *pb = ans;
250: }
251:
252: int
253: setcolor(ulong p, ulong r, ulong g, ulong b)
254: {
255: USED(p, r, g, b);
256: return 0; /* can't change mono screen colormap */
257: }
258:
259:
260: /*
261: * a fatter than usual cursor for the safari
262: */
263: Cursor fatarrow = {
264: { -1, -1 },
265: {
266: 0xff, 0xff, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0c,
267: 0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04,
268: 0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8c, 0x04,
269: 0x92, 0x08, 0x91, 0x10, 0xa0, 0xa0, 0xc0, 0x40,
270: },
271: {
272: 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfc, 0x7f, 0xf0,
273: 0x7f, 0xe0, 0x7f, 0xe0, 0x7f, 0xf0, 0x7f, 0xf8,
274: 0x7f, 0xfc, 0x7f, 0xfe, 0x7f, 0xfc, 0x73, 0xf8,
275: 0x61, 0xf0, 0x60, 0xe0, 0x40, 0x40, 0x00, 0x00,
276: },
277: };
278: void
279: bigcursor(void)
280: {
281: extern Cursor arrow;
282:
283: memmove(&arrow, &fatarrow, sizeof(fatarrow));
284: }
285:
286: int
287: hwgcmove(Point p)
288: {
289: USED(p);
290: return 0;
291: }
292:
293: void
294: setcursor(Cursor *curs)
295: {
296: uchar *p;
297: int i;
298: extern GBitmap set, clr;
299:
300: for(i = 0; i < 16; i++){
301: p = (uchar*)&set.base[i];
302: *p = curs->set[2*i];
303: *(p+1) = curs->set[2*i+1];
304: p = (uchar*)&clr.base[i];
305: *p = curs->clr[2*i];
306: *(p+1) = curs->clr[2*i+1];
307: }
308: }
309:
310: /*
311: * setup a serial mouse
312: */
313: static void
314: serialmouse(int port, char *type, int setspeed)
315: {
316: if(mousetype)
317: error(Emouseset);
318:
319: if(port >= 2 || port < 0)
320: error(Ebadarg);
321:
322: /* set up /dev/eia0 as the mouse */
323: sccspecial(port, 0, &mouseq, setspeed ? 1200 : 0);
324: if(type && *type == 'M')
325: mouseq.putc = m3mouseputc;
326: mousetype = Mouseserial;
327: }
328:
329: /*
330: * set/change mouse configuration
331: */
332: void
333: mousectl(char *arg)
334: {
335: int n;
336: char *field[3];
337:
338: n = getfields(arg, field, 3, " ");
339: if(strncmp(field[0], "serial", 6) == 0){
340: switch(n){
341: case 1:
342: serialmouse(atoi(field[0]+6), 0, 1);
343: break;
344: case 2:
345: serialmouse(atoi(field[1]), 0, 0);
346: break;
347: case 3:
348: default:
349: serialmouse(atoi(field[1]), field[2], 0);
350: break;
351: }
352: }
353: else
354: error(Ebadctl);
355: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.