![[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 / libis|
Return to events.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / libis |
1.1 root 1: /*
2: * $Source: /u1/X/libis/RCS/events.c,v $
3: * $Header: events.c,v 1.1 86/11/17 14:33:56 swick Rel $
4: */
5:
6: #ifndef lint
7: static char *rcsid_events_c = "$Header: events.c,v 1.1 86/11/17 14:33:56 swick Rel $";
8: #endif lint
9:
10: #include "is-copyright.h"
11:
12: /* events.c
13: *
14: * ProcessInput stub
15: * InputHandler Read IS input; convert to X event
16: *
17: * Copyright (c) 1986, Integrated Solutions, Inc.
18: */
19:
20: #include "Xis.h"
21: #include <fcntl.h>
22: #include "lk201.h"
23: #include <sys/time.h>
24:
25: #define IBUFSIZE 512
26: #define KEY_MASKS (ControlMask|MetaMask|ShiftMask|ShiftLockMask)
27:
28: /*
29: * taken from ../X/input.c
30: */
31: #define ShiftKeyCode 0256
32: #define ControlKeyCode 0257
33: #define LockKeyCode 0260
34: #define MetaKeyCode 0261
35:
36: #define VSE_LEFT_BUTTON 0
37: #define VSE_MIDDLE_BUTTON 1
38: #define VSE_RIGHT_BUTTON 2
39:
40: extern DEVICE *CurrentDevice;
41: extern int indev;
42: extern vsCursor last_mouse;
43:
44: int mouse_acceleration = 1;
45: int mouse_threshold;
46: int invalid_mouse;
47:
48: /*
49: * ProcessInput
50: */
51: /*ARGSUSED*/
52: ProcessInput(ev)
53: register vsEvent *ev;
54: {
55: /*NOTREACHED*/
56: }
57:
58: /*
59: * InputHandler
60: *
61: * It is assumed that read always returns complete sequences.
62: * Uses PF[1-4] to toggle ShiftKey, LockKey, ControlKey, and MetaKey.
63: */
64: int InputHandler()
65: {
66: unsigned char inbuf[IBUFSIZE];
67: register unsigned char *p = inbuf;
68: register int nread;
69:
70: #ifdef DEBUG
71: fflush(stdout);
72: #endif
73:
74: fcntl(indev, F_SETFL, FNDELAY);
75: if ((nread = read(indev, (char *)inbuf, IBUFSIZE)) <= 0) {
76: /* no input now */
77: fcntl(indev, F_SETFL, 0);
78: if (invalid_mouse)
79: --invalid_mouse;
80: return;
81: }
82:
83: while (p < &inbuf[nread]) {
84: static unsigned mask = 0;
85: vsEvent event;
86:
87: if (*p == VT_MOUSE) {
88: /* a mouse input */
89: int warp = 0;
90:
91: event.vse_device = VSE_MOUSE;
92: p++;
93:
94: /* which button */
95: switch (*p & (VT_MOUSE_LEFT|VT_MOUSE_MIDDLE|VT_MOUSE_RIGHT)) {
96: case VT_MOUSE_LEFT:
97: event.vse_key = VSE_LEFT_BUTTON;
98: break;
99: case VT_MOUSE_MIDDLE:
100: event.vse_key = VSE_MIDDLE_BUTTON;
101: break;
102: case VT_MOUSE_RIGHT:
103: event.vse_key = VSE_RIGHT_BUTTON;
104: break;
105: }
106:
107: /* which direction */
108: switch (*p++ & (VT_MOUSE_DOWN|VT_MOUSE_UP|VT_MOUSE_NOBUTTON)) {
109: case VT_MOUSE_DOWN:
110: event.vse_type = VSE_BUTTON;
111: event.vse_direction = VSE_KBTDOWN;
112: break;
113: case VT_MOUSE_UP:
114: event.vse_type = VSE_BUTTON;
115: event.vse_direction = VSE_KBTUP;
116: break;
117: case VT_MOUSE_NOBUTTON:
118: event.vse_type = VSE_MMOTION;
119: event.vse_direction = VSE_KBTRAW;
120: break;
121: }
122:
123: p++; /* window */
124: p++; /* pane */
125:
126: event.vse_x = *p++ << 8; event.vse_x |= *p++; /* x location */
127: event.vse_y = *p++ << 8; event.vse_y |= *p++; /* y location */
128:
129: if (invalid_mouse && (event.vse_type == VSE_MMOTION)) {
130: /* throw away buffered mouse motion events after warp */
131: continue;
132: }
133:
134: /* adjust for mouse acceleration if necessary */
135: if ((mouse_acceleration > 1) && (event.vse_type == VSE_MMOTION)) {
136: /* accelerated mouse */
137: register int delta;
138: delta = event.vse_x - last_mouse.x;
139: if ((delta < -mouse_threshold) || (delta > mouse_threshold)) {
140: /* accelerate mouse in x direction */
141: register short new_x;
142: warp = 1; /* will have to warp the mouse */
143: new_x = last_mouse.x +
144: ((delta<0?-1:1)*mouse_threshold)*(1-mouse_acceleration)
145: + (mouse_acceleration*delta);
146: /* keep warped mouse on the screen */
147: if (new_x >= ScreenPixmap.width)
148: event.vse_x = ScreenPixmap.width - 1;
149: else if (new_x < 0)
150: event.vse_x = 0;
151: else
152: event.vse_x = (unsigned short) new_x;
153: }
154: delta = event.vse_y - last_mouse.y;
155: if ((delta < -mouse_threshold) || (delta > mouse_threshold)) {
156: /* accelerate mouse in y direction */
157: register short new_y;
158: warp = 1; /* will have to warp the mouse */
159: new_y = last_mouse.y +
160: ((delta<0?-1:1)*mouse_threshold)*(1-mouse_acceleration)
161: + (mouse_acceleration*delta);
162: /* keep warped mouse on the screen */
163: if (new_y >= ScreenPixmap.height)
164: event.vse_y = ScreenPixmap.height - 1;
165: else if (new_y < 0)
166: event.vse_y = 0;
167: else
168: event.vse_y = (unsigned short) new_y;
169: }
170: }
171:
172: if (invalid_mouse && (event.vse_type != VSE_MMOTION)) {
173: /* don't throw away buffered mouse button events after warp */
174: /* but set them to warp location */
175: event.vse_x = last_mouse.x;
176: event.vse_y = last_mouse.y;
177: }
178:
179: if (warp)
180: SetCursorPosition((vsCursor *) &event);
181: else
182: UpdateCursorPosition((vsCursor *) &event);
183:
184: if (event.vse_type == VSE_MMOTION) {
185: register vsBox *b = CurrentDevice->mbox;
186: register vsCursor *m = CurrentDevice->mouse;
187: /* Has it left the box? */
188: if (m->y >= b->bottom || m->y < b->top ||
189: m->x >= b->right || m->x < b->left) {
190: b->bottom = 0;
191: Deal_with_movement();
192: }
193: } else {
194: /* a mouse button press or release */
195: struct timeval t;
196: struct timezone tz;
197: /* this is the best we can do for now */
198: gettimeofday(&t, &tz);
199: event.vse_time = t.tv_sec*100 + t.tv_usec/10000;
200: Deal_with_input(&event);
201: }
202: } else {
203: /* keyboard input */
204: struct timeval t;
205: struct timezone tz;
206: /* this is the best we can do for now */
207: gettimeofday(&t, &tz);
208: event.vse_time = t.tv_sec*100 + t.tv_usec/10000;
209: event.vse_type = VSE_BUTTON;
210: event.vse_device = VSE_DKB;
211: /* check for PF[1-4] (ESC O [PQRS]); assumes that if a */
212: /* complete PF escape sequence is in the buffer, it was */
213: /* produced by a PF key */
214: if ((&inbuf[nread] - p >= 3) &&
215: (*p == '\033') && (*(p+1) == 'O') &&
216: (*(p+2) >= 'P') && (*(p+2) <= 'S')) {
217: /* one of Shift, Lock, Control, Meta (PF[1-4]) was pressed */
218: switch (*(p+2)) { /* toggle the appropriate key */
219: case 'P': /* PF1 -- ShiftKey */
220: mask ^= ShiftMask;
221: event.vse_key = ShiftKeyCode;
222: event.vse_direction =
223: (mask & ShiftMask) ? VSE_KBTDOWN : VSE_KBTUP;
224: break;
225: case 'Q': /* PF2 -- LockKey */
226: mask ^= ShiftLockMask;
227: event.vse_key = LockKeyCode;
228: event.vse_direction =
229: (mask & ShiftLockMask) ? VSE_KBTDOWN : VSE_KBTUP;
230: break;
231: case 'R': /* PF3 -- ControlKey */
232: mask ^= ControlMask;
233: event.vse_key = ControlKeyCode;
234: event.vse_direction =
235: (mask & ControlMask) ? VSE_KBTDOWN : VSE_KBTUP;
236: break;
237: case 'S': /* PF4 -- MetaKey */
238: mask ^= MetaMask;
239: event.vse_key = MetaKeyCode;
240: event.vse_direction =
241: (mask & MetaMask) ? VSE_KBTDOWN : VSE_KBTUP;
242: break;
243: }
244: p += 3;
245: Deal_with_input(&event);
246: } else {
247: /* "normal" key */
248: register unsigned short key = LK201[*p++];
249: static vsEvent upkey = {0,0,0,VSE_BUTTON,0,VSE_KBTUP,VSE_DKB};
250: static vsEvent dnkey = {0,0,0,VSE_BUTTON,0,VSE_KBTDOWN,VSE_DKB};
251: upkey.vse_time = dnkey.vse_time = event.vse_time;
252:
253: /* send UP for any Shift, Lock, Control, or Meta keys down */
254: /* but not if this is a Shift or Control key */
255: if ((mask & ShiftMask) && !(key & ShiftMask)) {
256: upkey.vse_key = ShiftKeyCode;
257: Deal_with_input(&upkey);
258: }
259: if (mask & ShiftLockMask) {
260: upkey.vse_key = LockKeyCode;
261: Deal_with_input(&upkey);
262: }
263: if ((mask & ControlMask) && !(key & ControlMask)) {
264: upkey.vse_key = ControlKeyCode;
265: Deal_with_input(&upkey);
266: }
267: if (mask & MetaMask) {
268: upkey.vse_key = MetaKeyCode;
269: Deal_with_input(&upkey);
270: }
271:
272: /* set up keyboard event */
273: event.vse_key = key & 0377;
274: event.vse_direction = VSE_KBTRAW;
275:
276: switch (key & KEY_MASKS) {
277: case ShiftMask:
278: /* send Shift down if not down already */
279: if (!(mask & ShiftMask)) {
280: dnkey.vse_key = ShiftKeyCode;
281: Deal_with_input(&dnkey);
282: }
283: /* send the key */
284: Deal_with_input(&event);
285: /* send Shift up */
286: upkey.vse_key = ShiftKeyCode;
287: Deal_with_input(&upkey);
288: break;
289: case ControlMask:
290: /* send Control down if not down already */
291: if (!(mask & ControlMask)) {
292: dnkey.vse_key = ControlKeyCode;
293: Deal_with_input(&dnkey);
294: }
295: /* send the key */
296: Deal_with_input(&event);
297: /* send Control up */
298: upkey.vse_key = ControlKeyCode;
299: Deal_with_input(&upkey);
300: break;
301: case ShiftLockMask:
302: case MetaMask:
303: default:
304: /* send the key */
305: Deal_with_input(&event);
306: break;
307: }
308:
309: mask = 0; /* nothing should be down now */
310: }
311: }
312: fflush(stdout);
313: }
314: if (invalid_mouse)
315: --invalid_mouse;
316: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.