![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to events.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libsun|
Return to events.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libsun |
1.1 root 1: #ifndef lint
2: static char *rcsid_events_c = "$Header: events.c,v 10.4 86/12/17 20:36:45 swick Exp $";
3: #endif lint
4: #ifdef sun
5: /*
6: * The Sun X drivers are a product of Sun Microsystems, Inc. and are provided
7: * for unrestricted use provided that this legend is included on all tape
8: * media and as a part of the software program in whole or part. Users
9: * may copy or modify these drivers without charge, but are not authorized
10: * to license or distribute them to anyone else except as part of a product or
11: * program developed by the user.
12: *
13: * THE SUN X DRIVERS ARE PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND
14: * INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A
15: * PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE
16: * PRACTICE.
17: *
18: * The Sun X Drivers are provided with no support and without any obligation
19: * on the part of Sun Microsystems, Inc. to assist in their use, correction,
20: * modification or enhancement.
21: *
22: * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
23: * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THE SUN X
24: * DRIVERS OR ANY PART THEREOF.
25: *
26: * In no event will Sun Microsystems, Inc. be liable for any lost revenue
27: * or profits or other special, indirect and consequential damages, even if
28: * Sun has been advised of the possibility of such damages.
29: *
30: * Sun Microsystems, Inc.
31: * 2550 Garcia Avenue
32: * Mountain View, California 94043
33: */
34:
35: #ifndef lint
36: static char sccsid[] = "@(#)events.c 2.1 86/01/28 Copyright 1986 Sun Micro";
37: #endif
38:
39: /*-
40: * Copyright (c) 1986 by Sun Microsystems, Inc.
41: */
42:
43: /*
44: * ToDo:
45: * Up events on regular keys
46: */
47:
48: #include <stdio.h>
49: #include <sys/types.h>
50: #include <sys/time.h>
51: #include <sys/errno.h>
52: #include "../X/X.h"
53: #include "../X/vsinput.h"
54: #include "../X/Xdev.h"
55: #include <sundev/kbd.h>
56: #ifdef RAW_KBD
57: #include <sundev/kbio.h>
58: #endif
59: #include <sunwindow/win_input.h>
60:
61: #ifndef event_is_ascii
62: #define event_is_ascii(e) (e->ie_code >= ASCII_FIRST && e->ie_code <= ASCII_LAST)
63: #endif
64: #ifndef event_is_meta
65: #define event_is_meta(e) (e->ie_code >= META_FIRST && e->ie_code <= META_LAST)
66: #endif
67: /* Should be qevent.h */
68: #define VSE_LEFT_BUTTON 0
69: #define VSE_MIDDLE_BUTTON 1
70: #define VSE_RIGHT_BUTTON 2
71: #define NOT_A_KEY 9
72:
73: extern int errno;
74: extern int vsdev;
75: extern DEVICE *CurrentDevice;
76:
77: int sunthreshold = 0;
78: int sunaccel = 0;
79:
80: #ifdef RAW_KBD
81: extern unsigned state_mask;
82: #endif
83:
84: /*ARGSUSED*/
85: ProcessInput(ev)
86: register vsEvent *ev;
87: {
88: /*NOTREACHED*/
89: }
90:
91: #include "lk201.h"
92:
93: #ifdef RAW_KBD
94: extern struct kiockey sunkeymap[];
95:
96: /*
97: * Convert from a Sun event to an X event
98: */
99: unsigned
100: ConvertEvent(se, xe)
101: struct inputevent *se;
102: vsEvent *xe;
103: {
104: int key;
105: unsigned kludgekey;
106: /* Map the coordinates */
107: xe->vse_x = se->ie_locx;
108: xe->vse_y = se->ie_locy;
109: /* Map the time stamps */
110: xe->vse_time = (se->ie_time.tv_usec/10000 + se->ie_time.tv_sec);
111: /* Set direction */
112: xe->vse_direction = (win_inputposevent(se) ? VSE_KBTDOWN : VSE_KBTUP);
113: /* Sort out the event codes */
114:
115: if (se->ie_code >= VKEY_FIRSTSHIFT && se->ie_code <= VKEY_LASTSHIFT) {
116: /*
117: * this makes ie_code between 0 and 0200 inclusive.
118: */
119: se->ie_code -= VKEY_FIRSTSHIFT;
120: key = SHIFTKEYS + se->ie_code;
121: } else if (se->ie_code >= 0 && se->ie_code < 0200)
122: key = sunkeymap[se->ie_code].kio_entry;
123: else
124: key = -1;
125:
126: kludgekey = 0;
127: if (key >= 0) {
128: xe->vse_device = VSE_DKB;
129: xe->vse_type = VSE_BUTTON;
130:
131: /*
132: * First deal with special keycodes
133: */
134: if (key & 0x80) {
135: switch(key & 0xf0) {
136: case SHIFTKEYS:
137: /*
138: * The static count is keeping track of how many
139: * keys I have down for the given function.
140: * Only need to do this for shift and meta.
141: * On an up event I decrease the count. If it is
142: * not the last one up then I convert to a down event
143: * which really won't do anything. I should ignore
144: * the event, but this works.
145: * At odd times the sun keyboard gets confused and I
146: * miss an UP event. This may get you stuck in
147: * shift mode. I assume there is only 2 shift keys
148: * and only two meta keys. If count ever goes above
149: * 2 I make it 2 again, assuming I have missed an up
150: * event. If you get stuck in shifted mode, just his
151: * both shift keys and you should be fixed.
152: */
153: switch(key & 0x0f) {
154: case 11:
155: case 14:
156: case LEFTSHIFT:
157: case RIGHTSHIFT: {
158: static count;
159:
160: kludgekey = 0256;
161:
162: if (win_inputposevent(se)) {
163: if (++count > 2)
164: count = 2;
165: } else if (--count > 0)
166: xe->vse_direction = VSE_KBTDOWN;
167: else if (count < 0)
168: count = 0;
169: break;
170: }
171: /* LEFT/RIGHT key */
172: case 9:
173: default: {
174: static count;
175:
176: kludgekey = 0261;
177:
178: if (win_inputposevent(se)) {
179: if (++count > 2)
180: count = 2;
181: } else if (--count > 0)
182: xe->vse_direction = VSE_KBTDOWN;
183: else if (count < 0)
184: count = 0;
185: break;
186: }
187: case 10:
188: case 13:
189: case CAPSLOCK:
190: case SHIFTLOCK:
191: kludgekey = 0260;
192: break;
193: case 12:
194: case 15:
195: case LEFTCTRL:
196: case RIGHTCTRL:
197: kludgekey = 0257;
198: break;
199: }
200: break;
201: case STRING:
202: switch(key & 0xf) {
203: default:
204: case HOMEARROW:
205: kludgekey = 0206;
206: break;
207: case UPARROW:
208: kludgekey = 0252;
209: break;
210: case DOWNARROW:
211: kludgekey = 0251;
212: break;
213: case LEFTARROW:
214: kludgekey = 0247;
215: break;
216: case RIGHTARROW:
217: kludgekey = 0250;
218: break;
219: }
220: break;
221: case RIGHTFUNC:
222: kludgekey = RightKeys[key&0xf];
223: break;
224: case LEFTFUNC:
225: kludgekey = LeftKeys[key&0xf];
226: break;
227: case TOPFUNC:
228: kludgekey = TopKeys[key&0xf];
229: break;
230: case BOTTOMFUNC:
231: kludgekey = BotKeys[key&0xf];
232: break;
233: case BUCKYBITS:
234: case FUNNY:
235: default:
236: kludgekey = 0;
237: }
238: } else {
239: /*
240: * Now deal with regular keys.
241: * Note, I look up the key in the shift/ctrl/caps tables
242: * in case the keys are not quite like a lk201.
243: * I assume that a regular key shifted/ctrled/caped is also a
244: * regular key. This may be naive.
245: */
246: if (key == '\033' /*ESC*/ )
247: kludgekey = 0161;
248: else if (key == '\b')
249: kludgekey = 0162;
250: else if (key == '\n')
251: kludgekey = 0163;
252: else if (key == '\r')
253: kludgekey = 0275;
254: else if (key == '\t')
255: kludgekey = 0276;
256: else if (key == '\006' /*ALT*/)
257: kludgekey = 0245;
258: else if (key == '\177' /*DEL*/)
259: kludgekey = 0274;
260: else if(state_mask & ControlMask)
261: kludgekey = LK201[sunkeymap[se->ie_code+00200].kio_entry];
262: else if(state_mask & ShiftMask)
263: kludgekey = LK201[sunkeymap[se->ie_code+00600].kio_entry];
264: else if(state_mask & ShiftLockMask)
265: kludgekey = LK201[sunkeymap[se->ie_code+00400].kio_entry];
266: else
267: kludgekey = LK201[key];
268: }
269: xe->vse_key = kludgekey & 0377;
270: kludgekey &= (~state_mask)&(ControlMask|ShiftMask);
271: } else switch (se->ie_code) {
272: case LOC_MOVE:
273: xe->vse_device = VSE_MOUSE; /* XXX - should query shift state here but ... */
274: xe->vse_type = VSE_MMOTION;
275: break;
276: case MS_LEFT:
277: xe->vse_key = VSE_LEFT_BUTTON;
278: xe->vse_device = VSE_MOUSE;
279: xe->vse_type = VSE_BUTTON;
280: break;
281: case MS_MIDDLE:
282: xe->vse_device = VSE_MOUSE;
283: xe->vse_type = VSE_BUTTON;
284: xe->vse_key = VSE_MIDDLE_BUTTON;
285: break;
286: case MS_RIGHT:
287: xe->vse_key = VSE_RIGHT_BUTTON;
288: xe->vse_device = VSE_MOUSE;
289: xe->vse_type = VSE_BUTTON;
290: break;
291: default:
292: xe->vse_key = NOT_A_KEY;
293: xe->vse_device = VSE_MOUSE;
294: xe->vse_type = VSE_BUTTON;
295: break;
296: }
297: return(kludgekey);
298: }
299:
300: #define INPBUFSIZE 128
301:
302: /*
303: * Read pending input events
304: */
305: InputReader()
306: {
307: struct inputevent sunevents[INPBUFSIZE];
308: int n, m;
309:
310: if ((n = read(vsdev, sunevents, INPBUFSIZE * sizeof sunevents[0])) < 0
311: && errno != EWOULDBLOCK) {
312: /*
313: * Error reading events
314: */
315: /* XXX_DO_SOMETHING(); */
316: return;
317: }
318: for (n /= sizeof sunevents[0], m = 0; m < n; m++) {
319: vsEvent Xevent;
320:
321: unsigned kludgekey = ConvertEvent(&(sunevents[m]), &Xevent);
322:
323: if (Xevent.vse_type == VSE_MMOTION) {
324: if (sunthreshold) {
325: int dx = Xevent.vse_x - CurrentDevice->mouse->x;
326: int dy = Xevent.vse_y - CurrentDevice->mouse->y;
327:
328: if (sunthreshold <= (dx > 0 ? dx : -dx) + (dy > 0 ? dy : -dy)) {
329: Xevent.vse_x = CurrentDevice->mouse->x + dx * sunaccel;
330: Xevent.vse_y = CurrentDevice->mouse->y + dy * sunaccel;
331: }
332:
333: }
334: SetCursorPosition((vsCursor *) &Xevent); /* XXX - tacky */
335: }
336:
337: Xevent.vse_key;
338:
339: if (Xevent.vse_type == VSE_MMOTION) {
340: register vsBox *b = CurrentDevice->mbox;
341: register vsCursor *m = CurrentDevice->mouse;
342: /*
343: * Has it left the box?
344: */
345: if (m->y >= b->bottom || m->y < b->top ||
346: m->x >= b->right || m->x < b->left) {
347: b->bottom = 0;
348: Deal_with_movement();
349: }
350: } else if (Xevent.vse_key != NOT_A_KEY ||
351: Xevent.vse_device != VSE_MOUSE) {
352: state_mask |= kludgekey;
353: Deal_with_input(&Xevent);
354: state_mask &= ~kludgekey;
355: }
356: }
357: }
358: #else
359: static int
360: SunToXKeyCode(s)
361: int s;
362: {
363: register int ret = LK201[s&0177];
364: char *c = "^.";
365: char *f = ".";
366:
367: c[1] = (s&0177)|0100;
368: f[0] = (s&0177);
369:
370: return(ret);
371: }
372:
373: /*
374: * Convert from a Sun event to an X event
375: */
376: int
377: ConvertEvent(se, xe)
378: struct inputevent *se;
379: vsEvent *xe;
380: {
381: static unsigned lstate_mask;
382:
383: /* Map the coordinates */
384: xe->vse_x = se->ie_locx;
385: xe->vse_y = se->ie_locy;
386: /* Map the time stamps */
387: xe->vse_time = (se->ie_time.tv_usec/10000 + se->ie_time.tv_sec);
388: /* Set direction */
389: xe->vse_direction = (win_inputposevent(se) ? VSE_KBTDOWN : VSE_KBTUP);
390: /* Sort out the event codes */
391: if (event_is_ascii(se)) {
392: /* ASCII keystroke */
393: int key = SunToXKeyCode(se->ie_code);
394: xe->vse_key = (key & 0377);
395: xe->vse_device = VSE_DKB;
396: xe->vse_type = VSE_BUTTON;
397: lstate_mask = (lstate_mask & ~(ControlMask|MetaMask|ShiftMask))
398: | (key & (ControlMask|MetaMask|ShiftMask));
399: } else if (event_is_meta(se)) {
400: /* META keystroke - map to ASCII for now */
401: int key = SunToXKeyCode(se->ie_code - META_FIRST + ASCII_FIRST) | MetaMask;
402: xe->vse_key = (key & 0377);
403: xe->vse_device = VSE_DKB;
404: xe->vse_type = VSE_BUTTON;
405: lstate_mask = (lstate_mask & ~(ControlMask|MetaMask|ShiftMask))
406: | (key & (ControlMask|MetaMask|ShiftMask));
407: } else switch (se->ie_code) {
408: case LOC_MOVE:
409: xe->vse_device = VSE_MOUSE; /* XXX - should query shift state here but ... */
410: xe->vse_type = VSE_MMOTION;
411: break;
412: case MS_LEFT:
413: xe->vse_key = VSE_LEFT_BUTTON;
414: xe->vse_device = VSE_MOUSE;
415: xe->vse_type = VSE_BUTTON;
416: if (xe->vse_direction == VSE_KBTUP)
417: lstate_mask &= ~LeftMask;
418: else
419: lstate_mask |= LeftMask;
420: goto ShiftKeys;
421: case MS_MIDDLE:
422: xe->vse_device = VSE_MOUSE;
423: xe->vse_type = VSE_BUTTON;
424: xe->vse_key = VSE_MIDDLE_BUTTON;
425: if (xe->vse_direction == VSE_KBTUP)
426: lstate_mask &= ~MiddleMask;
427: else
428: lstate_mask |= MiddleMask;
429: goto ShiftKeys;
430: case MS_RIGHT:
431: xe->vse_key = VSE_RIGHT_BUTTON;
432: xe->vse_device = VSE_MOUSE;
433: xe->vse_type = VSE_BUTTON;
434: if (xe->vse_direction == VSE_KBTUP)
435: lstate_mask &= ~RightMask;
436: else
437: lstate_mask |= RightMask;
438: goto ShiftKeys;
439: default:
440: xe->vse_key = NOT_A_KEY;
441: xe->vse_device = VSE_MOUSE;
442: xe->vse_type = VSE_BUTTON;
443: if (xe->vse_direction == VSE_KBTUP)
444: lstate_mask &= ~ShiftLockMask;
445: else
446: lstate_mask |= ShiftLockMask;
447: ShiftKeys:
448: if (se->ie_shiftmask & SHIFTMASK)
449: lstate_mask |= ShiftMask;
450: else
451: lstate_mask &= ~ShiftMask;
452: if (se->ie_shiftmask & CTRLMASK)
453: lstate_mask |= ControlMask;
454: else
455: lstate_mask &= ~ControlMask;
456: #ifdef META_SHIFT_MASK
457: if (se->ie_shiftmask & META_SHIFT_MASK)
458: lstate_mask |= MetaMask;
459: else
460: lstate_mask &= ~MetaMask;
461: #endif
462: break;
463: }
464: return (lstate_mask);
465: }
466:
467: #define INPBUFSIZE 128
468:
469: /*
470: * Read pending input events
471: */
472: InputReader()
473: {
474: struct inputevent sunevents[INPBUFSIZE];
475: int n, m;
476: static int last_mask;
477:
478: if ((n = read(vsdev, sunevents, INPBUFSIZE * sizeof sunevents[0])) < 0
479: && errno != EWOULDBLOCK) {
480: /*
481: * Error reading events
482: */
483: /* XXX_DO_SOMETHING(); */
484: return;
485: }
486: for (n /= sizeof sunevents[0], m = 0; m < n; m++) {
487: vsEvent Xevent, Sevent;
488: int mask;
489:
490: mask = ConvertEvent(&(sunevents[m]), &Xevent);
491: if (Xevent.vse_type == VSE_MMOTION) {
492: if (sunthreshold) {
493: int dx = Xevent.vse_x - CurrentDevice->mouse->x;
494: int dy = Xevent.vse_y - CurrentDevice->mouse->y;
495:
496: if (sunthreshold <= (dx > 0 ? dx : -dx) + (dy > 0 ? dy : -dy)) {
497: Xevent.vse_x = CurrentDevice->mouse->x + dx * sunaccel;
498: Xevent.vse_y = CurrentDevice->mouse->y + dy * sunaccel;
499: }
500:
501: }
502: SetCursorPosition((vsCursor *) &Xevent); /* XXX - tacky */
503: }
504:
505: if (mask != last_mask) {
506: last_mask ^= mask;
507: Sevent.vse_device = VSE_DKB;
508: Sevent.vse_x = Xevent.vse_x;
509: Sevent.vse_y = Xevent.vse_y;
510: Sevent.vse_time = Xevent.vse_time;
511: if (last_mask & ShiftMask) {
512: if (mask & ShiftMask)
513: Sevent.vse_direction = VSE_KBTDOWN;
514: else
515: Sevent.vse_direction = VSE_KBTUP;
516: Sevent.vse_key = 0256;
517: Deal_with_input(&Sevent);
518: }
519: if (last_mask & ControlMask) {
520: if (mask & ControlMask)
521: Sevent.vse_direction = VSE_KBTDOWN;
522: else
523: Sevent.vse_direction = VSE_KBTUP;
524: Sevent.vse_key = 0257;
525: Deal_with_input(&Sevent);
526: }
527: if (last_mask & ShiftLockMask) {
528: if (mask & ShiftLockMask)
529: Sevent.vse_direction = VSE_KBTDOWN;
530: else
531: Sevent.vse_direction = VSE_KBTUP;
532: Sevent.vse_key = 0260;
533: Deal_with_input(&Sevent);
534: }
535: if (last_mask & MetaMask) {
536: if (mask & MetaMask)
537: Sevent.vse_direction = VSE_KBTDOWN;
538: else
539: Sevent.vse_direction = VSE_KBTUP;
540: Sevent.vse_key = 0261;
541: Deal_with_input(&Sevent);
542: }
543: last_mask = mask;
544: }
545: if (Xevent.vse_type == VSE_MMOTION) {
546: register vsBox *b = CurrentDevice->mbox;
547: register vsCursor *m = CurrentDevice->mouse;
548: /*
549: * Has it left the box?
550: */
551: if (m->y >= b->bottom || m->y < b->top ||
552: m->x >= b->right || m->x < b->left) {
553: b->bottom = 0;
554: Deal_with_movement();
555: }
556: } else if (Xevent.vse_key != NOT_A_KEY ||
557: Xevent.vse_device != VSE_MOUSE)
558: Deal_with_input(&Xevent);
559: }
560: }
561: #endif
562: #endif sun
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.