![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sunKbd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun|
Return to sunKbd.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / server / ddx / sun |
1.1 root 1: /*-
2: * sunKbd.c --
3: * Functions for retrieving data from a keyboard.
4: *
5: * Copyright (c) 1987 by the Regents of the University of California
6: *
7: * Permission to use, copy, modify, and distribute this
8: * software and its documentation for any purpose and without
9: * fee is hereby granted, provided that the above copyright
10: * notice appear in all copies. The University of California
11: * makes no representations about the suitability of this
12: * software for any purpose. It is provided "as is" without
13: * express or implied warranty.
14: *
15: */
16:
17: /************************************************************
18: Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
19:
20: All Rights Reserved
21:
22: Permission to use, copy, modify, and distribute this
23: software and its documentation for any purpose and without
24: fee is hereby granted, provided that the above copyright no-
25: tice appear in all copies and that both that copyright no-
26: tice and this permission notice appear in supporting docu-
27: mentation, and that the names of Sun or MIT not be used in
28: advertising or publicity pertaining to distribution of the
29: software without specific prior written permission. Sun and
30: M.I.T. make no representations about the suitability of this
31: software for any purpose. It is provided "as is" without any
32: express or implied warranty.
33:
34: SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
35: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
36: NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
37: ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
38: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
39: PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
40: OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
41: THE USE OR PERFORMANCE OF THIS SOFTWARE.
42:
43: ********************************************************/
44:
45: #ifndef lint
46: static char sccsid[] = "%W %G Copyright 1987 Sun Micro";
47: #endif
48:
49: #define NEED_EVENTS
50: #include "sun.h"
51: #include <stdio.h>
52: #include "Xproto.h"
53: #include "keysym.h"
54:
55: typedef struct {
56: int trans; /* Original translation form */
57: } SunKbPrivRec, *SunKbPrivPtr;
58:
59: extern CARD8 *sunModMap[];
60: extern KeySymsRec sunKeySyms[];
61:
62: static void sunBell();
63: static void sunKbdCtrl();
64: static Firm_event *sunKbdGetEvents();
65: static void sunKbdProcessEvent();
66: static void sunKbdDoneEvents();
67: int autoRepeatKeyDown = 0;
68: int autoRepeatDebug = 0;
69: int autoRepeatReady;
70: static int autoRepeatFirst;
71: static struct timeval autoRepeatLastKeyDownTv;
72: static struct timeval autoRepeatDeltaTv;
73: #define tvminus(tv, tv1, tv2) /* tv = tv1 - tv2 */ \
74: if ((tv1).tv_usec < (tv2).tv_usec) { \
75: (tv1).tv_usec += 1000000; \
76: (tv1).tv_sec -= 1; \
77: } \
78: (tv).tv_usec = (tv1).tv_usec - (tv2).tv_usec; \
79: (tv).tv_sec = (tv1).tv_sec - (tv2).tv_sec;
80: #define tvplus(tv, tv1, tv2) /* tv = tv1 + tv2 */ \
81: (tv).tv_sec = (tv1).tv_sec + (tv2).tv_sec; \
82: (tv).tv_usec = (tv1).tv_usec + (tv2).tv_usec; \
83: if ((tv).tv_usec > 1000000) { \
84: (tv).tv_usec -= 1000000; \
85: (tv).tv_sec += 1; \
86: }
87:
88:
89: static SunKbPrivRec sunKbPriv;
90: static KbPrivRec sysKbPriv = {
91: -1, /* Type of keyboard */
92: -1, /* Descriptor open to device */
93: sunKbdGetEvents, /* Function to read events */
94: sunKbdProcessEvent, /* Function to process an event */
95: sunKbdDoneEvents, /* Function called when all events */
96: /* have been handled. */
97: (pointer)&sunKbPriv, /* Private to keyboard device */
98: (Bool)0, /* Mapped queue */
99: 0, /* offset for device keycodes */
100: };
101:
102: /*-
103: *-----------------------------------------------------------------------
104: * sunKbdProc --
105: * Handle the initialization, etc. of a keyboard.
106: *
107: * Results:
108: * None.
109: *
110: * Side Effects:
111: *
112: * Note:
113: * When using sunwindows, all input comes off a single fd, stored in the
114: * global windowFd. Therefore, only one device should be enabled and
115: * disabled, even though the application still sees both mouse and
116: * keyboard. We have arbitrarily chosen to enable and disable windowFd
117: * in the keyboard routine sunKbdProc rather than in sunMouseProc.
118: *
119: *-----------------------------------------------------------------------
120: */
121: int
122: sunKbdProc (pKeyboard, what)
123: DevicePtr pKeyboard; /* Keyboard to manipulate */
124: int what; /* What to do to it */
125: {
126: KbPrivPtr pPriv;
127: register int kbdFd;
128:
129: switch (what) {
130: case DEVICE_INIT:
131: if (pKeyboard != LookupKeyboardDevice()) {
132: ErrorF ("Cannot open non-system keyboard");
133: return (!Success);
134: }
135:
136: /*
137: * First open and find the current state of the keyboard.
138: */
139: if (sysKbPriv.fd >= 0) {
140: kbdFd = sysKbPriv.fd;
141: } else {
142: kbdFd = open ("/dev/kbd", O_RDWR, 0);
143: if (kbdFd < 0) {
144: Error ("Opening /dev/kbd");
145: return (!Success);
146: }
147: sysKbPriv.fd = kbdFd;
148: (void) ioctl (kbdFd, KIOCTYPE, &sysKbPriv.type);
149: (void) ioctl (kbdFd, KIOCGTRANS, &sunKbPriv.trans);
150: if (sysKbPriv.type < 0 || sysKbPriv.type > KB_SUN3
151: || sunKeySyms[sysKbPriv.type].map == NULL)
152: FatalError("Unsupported keyboard type %d\n",
153: sysKbPriv.type);
154: if (sunUseSunWindows()) {
155: (void) close( kbdFd );
156: sysKbPriv.fd = -1;
157: } else {
158: if (fcntl (kbdFd, F_SETFL, (FNDELAY|FASYNC)) < 0
159: || fcntl(kbdFd, F_SETOWN, getpid()) < 0) {
160: perror("sunKbdProc");
161: FatalError("Can't set up kbd on fd %d\n", kbdFd);
162: }
163: }
164: }
165:
166: /*
167: * Perform final initialization of the system private keyboard
168: * structure and fill in various slots in the device record
169: * itself which couldn't be filled in before.
170: */
171: pKeyboard->devicePrivate = (pointer)&sysKbPriv;
172:
173: pKeyboard->on = FALSE;
174: /*
175: * ensure that the keycodes on the wire are >= MIN_KEYCODE
176: */
177: if (sunKeySyms[sysKbPriv.type].minKeyCode < MIN_KEYCODE) {
178: int offset = MIN_KEYCODE -sunKeySyms[sysKbPriv.type].minKeyCode;
179:
180: sunKeySyms[sysKbPriv.type].minKeyCode += offset;
181: sunKeySyms[sysKbPriv.type].maxKeyCode += offset;
182: sysKbPriv.offset = offset;
183: }
184: InitKeyboardDeviceStruct(
185: pKeyboard,
186: &(sunKeySyms[sysKbPriv.type]),
187: (sunModMap[sysKbPriv.type]),
188: sunBell,
189: sunKbdCtrl);
190: break;
191:
192: case DEVICE_ON:
193: if (sunUseSunWindows()) {
194: #ifdef SUN_WINDOWS
195: if (! sunSetUpKbdSunWin(windowFd, TRUE, pKeyboard)) {
196: FatalError("Can't set up keyboard\n");
197: }
198: AddEnabledDevice(windowFd);
199: #endif SUN_WINDOWS
200: }
201: else {
202: pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
203: kbdFd = pPriv->fd;
204:
205: /*
206: * Set the keyboard into "direct" mode and turn on
207: * event translation.
208: */
209: if (sunChangeKbdTranslation(pKeyboard,TRUE) < 0) {
210: FatalError("Can't set keyboard translation\n");
211: }
212:
213: AddEnabledDevice(kbdFd);
214: }
215: pKeyboard->on = TRUE;
216: break;
217:
218: case DEVICE_CLOSE:
219: case DEVICE_OFF:
220: if (sunUseSunWindows()) {
221: #ifdef SUN_WINDOWS
222: if (! sunSetUpKbdSunWin(windowFd, FALSE, pKeyboard)) {
223: FatalError("Can't close keyboard\n");
224: }
225: RemoveEnabledDevice(windowFd);
226: #endif SUN_WINDOWS
227: }
228: else {
229: pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
230: kbdFd = pPriv->fd;
231:
232: /*
233: * Restore original keyboard directness and translation.
234: */
235: if (sunChangeKbdTranslation(pKeyboard,FALSE) < 0) {
236: FatalError("Can't reset keyboard translation\n");
237: }
238:
239: RemoveEnabledDevice(kbdFd);
240: }
241: pKeyboard->on = FALSE;
242: break;
243: }
244: return (Success);
245: }
246:
247: /*-
248: *-----------------------------------------------------------------------
249: * sunBell --
250: * Ring the terminal/keyboard bell
251: *
252: * Results:
253: * None.
254: *
255: * Side Effects:
256: * None, really...
257: *
258: *-----------------------------------------------------------------------
259: */
260: static void
261: sunBell (loudness, pKeyboard)
262: int loudness; /* Percentage of full volume */
263: DevicePtr pKeyboard; /* Keyboard to ring */
264: {
265: /* no can do, for now */
266: }
267:
268: /*-
269: *-----------------------------------------------------------------------
270: * sunKbdCtrl --
271: * Alter some of the keyboard control parameters
272: *
273: * Results:
274: * None.
275: *
276: * Side Effects:
277: * Some...
278: *
279: *-----------------------------------------------------------------------
280: */
281: static void
282: sunKbdCtrl (pKeyboard)
283: DevicePtr pKeyboard; /* Keyboard to alter */
284: {
285: /* can only change key click on sun 3 keyboards, so what's the use? */
286: }
287:
288: /*-
289: *-----------------------------------------------------------------------
290: * sunKbdGetEvents --
291: * Return the events waiting in the wings for the given keyboard.
292: *
293: * Results:
294: * A pointer to an array of Firm_events or (Firm_event *)0 if no events
295: * The number of events contained in the array.
296: * If there are no keyboard events ready and autoRepeatKeyDown > 0,
297: * then *pNumEvents is set to 1 and Firm_event id is set to
298: * AUTOREPEAT_EVENTID. In sunKbdProcessEvent, if autoRepeatKeyDown > 0
299: * and Firm_event id == AUTOREPEAT_EVENTID, then the event buffer is
300: * ignored and the event is generated from the last KeyPress event.
301: *
302: * Side Effects:
303: * None.
304: *-----------------------------------------------------------------------
305: */
306: static Firm_event *
307: sunKbdGetEvents (pKeyboard, pNumEvents)
308: DevicePtr pKeyboard; /* Keyboard to read */
309: int *pNumEvents; /* Place to return number of events */
310: {
311: int nBytes; /* number of bytes of events available. */
312: KbPrivPtr pPriv;
313: static Firm_event evBuf[MAXEVENTS]; /* Buffer for Firm_events */
314:
315: pPriv = (KbPrivPtr) pKeyboard->devicePrivate;
316: nBytes = read (pPriv->fd, evBuf, sizeof(evBuf));
317:
318: if (nBytes < 0) {
319: if (errno == EWOULDBLOCK) {
320: *pNumEvents = 0;
321: } else {
322: Error ("Reading keyboard");
323: FatalError ("Could not read the keyboard");
324: }
325: } else {
326: *pNumEvents = nBytes / sizeof (Firm_event);
327: }
328:
329: if (autoRepeatKeyDown && autoRepeatReady && *pNumEvents == 0) {
330: *pNumEvents = 1; /* Fake the event */
331: evBuf[0].id = AUTOREPEAT_EVENTID; /* Flags autoRepeat event */
332: if (autoRepeatDebug)
333: ErrorF("sunKbdGetEvents: autoRepeatKeyDown = %d event\n",
334: autoRepeatKeyDown);
335: }
336:
337: return (evBuf);
338: }
339:
340: /*-
341: *-----------------------------------------------------------------------
342: * sunKbdProcessEvent --
343: *
344: * Results:
345: *
346: * Side Effects:
347: *
348: * Caveat:
349: * To reduce duplication of code and logic (and therefore bugs), the
350: * sunwindows version of kbd processing (sunKbdProcessEventSunWin())
351: * counterfeits a firm event and calls this routine. This
352: * couunterfeiting relies on the fact this this routine only looks at the
353: * id, time, and value fields of the firm event which it is passed. If
354: * this ever changes, the sunKbdProcessEventSunWin will also have to
355: * change.
356: *
357: *-----------------------------------------------------------------------
358: */
359: static void
360: sunKbdProcessEvent (pKeyboard, fe)
361: DevicePtr pKeyboard;
362: Firm_event *fe;
363: {
364: xEvent xE;
365: PtrPrivPtr ptrPriv;
366: int delta;
367: static xEvent autoRepeatEvent;
368:
369: ptrPriv = (PtrPrivPtr) LookupPointerDevice()->devicePrivate;
370:
371: if (autoRepeatKeyDown && fe->id == AUTOREPEAT_EVENTID) {
372: /*
373: * Generate auto repeat event. XXX one for now.
374: * Update time & pointer location of saved KeyPress event.
375: */
376: if (autoRepeatDebug)
377: ErrorF("sunKbdProcessEvent: autoRepeatKeyDown = %d\n",
378: autoRepeatKeyDown);
379:
380: delta = TVTOMILLI(autoRepeatDeltaTv) / 2;
381: if (autoRepeatFirst == TRUE)
382: autoRepeatFirst = FALSE;
383:
384: /*
385: * Fake a key up event and a key down event
386: * for the last key pressed.
387: */
388: autoRepeatEvent.u.keyButtonPointer.time += delta;
389: autoRepeatEvent.u.keyButtonPointer.rootX = ptrPriv->x;
390: autoRepeatEvent.u.keyButtonPointer.rootY = ptrPriv->y;
391: autoRepeatEvent.u.u.type = KeyRelease;
392: (* pKeyboard->processInputProc) (&autoRepeatEvent, pKeyboard);
393:
394: autoRepeatEvent.u.keyButtonPointer.time += delta;
395: autoRepeatEvent.u.u.type = KeyPress;
396: (* pKeyboard->processInputProc) (&autoRepeatEvent, pKeyboard);
397:
398: /* Update time of last key down */
399: tvplus(autoRepeatLastKeyDownTv, autoRepeatLastKeyDownTv,
400: autoRepeatDeltaTv);
401:
402: return;
403: }
404:
405: /*
406: * Kill AutoRepeater on any real Kbd event.
407: */
408: autoRepeatKeyDown = 0;
409: if (autoRepeatDebug)
410: ErrorF("sunKbdProcessEvent: autoRepeat off\n");
411:
412: xE.u.keyButtonPointer.time = TVTOMILLI(fe->time);
413: xE.u.keyButtonPointer.rootX = ptrPriv->x;
414: xE.u.keyButtonPointer.rootY = ptrPriv->y;
415: xE.u.u.type = ((fe->value == VKEY_UP) ? KeyRelease : KeyPress);
416: xE.u.u.detail = (fe->id & 0x7F) + sysKbPriv.offset;
417:
418: if (fe->value == VKEY_DOWN) { /* turn on AutoRepeater */
419: if (autoRepeatDebug)
420: ErrorF("sunKbdProcessEvent: VKEY_DOWN\n");
421: autoRepeatEvent = xE;
422: autoRepeatFirst = TRUE;
423: autoRepeatKeyDown++;
424: autoRepeatLastKeyDownTv = fe->time;
425: }
426:
427: (* pKeyboard->processInputProc) (&xE, pKeyboard);
428: }
429:
430: /*-
431: *-----------------------------------------------------------------------
432: * sunDoneEvents --
433: * Nothing to do, here...
434: *
435: * Results:
436: *
437: * Side Effects:
438: *
439: *-----------------------------------------------------------------------
440: */
441: static void
442: sunKbdDoneEvents (pKeyboard)
443: DevicePtr pKeyboard;
444: {
445: }
446:
447: /*-
448: *-----------------------------------------------------------------------
449: * sunChangeKbdTranslation
450: * Makes operating system calls to set keyboard translation
451: * and direction on or off.
452: *
453: * Results:
454: * -1 if failure, else 0.
455: *
456: * Side Effects:
457: * Changes kernel management of keyboard.
458: *
459: *-----------------------------------------------------------------------
460: */
461: int
462: sunChangeKbdTranslation(pKeyboard,makeTranslated)
463: DevicePtr pKeyboard;
464: Bool makeTranslated;
465: {
466: KbPrivPtr pPriv;
467: int kbdFd;
468: int tmp;
469: int KbdOpenedHere;
470:
471: pPriv = (KbPrivPtr)pKeyboard->devicePrivate;
472: kbdFd = pPriv->fd;
473:
474: KbdOpenedHere = ( kbdFd < 0 );
475: if ( KbdOpenedHere ) {
476: kbdFd = open("/dev/kbd", O_RDONLY, 0);
477: if ( kbdFd < 0 ) {
478: Error( "sunChangeKbdTranslation: Can't open keyboard" );
479: goto bad;
480: }
481: }
482:
483: if (makeTranslated) {
484: /*
485: * Next set the keyboard into "direct" mode and turn on
486: * event translation. If either of these fails, we can't go
487: * on.
488: */
489: if ( ! sunUseSunWindows() ) {
490: tmp = 1;
491: if (ioctl (kbdFd, KIOCSDIRECT, &tmp) < 0) {
492: Error ("Setting keyboard direct mode");
493: goto bad;
494: }
495: }
496: tmp = TR_UNTRANS_EVENT;
497: if (ioctl (kbdFd, KIOCTRANS, &tmp) < 0) {
498: Error ("Setting keyboard translation");
499: goto bad;
500: }
501: }
502: else {
503: /*
504: * Next set the keyboard into "indirect" mode and turn off
505: * event translation.
506: */
507: if ( ! sunUseSunWindows() ) {
508: tmp = 0;
509: (void)ioctl (kbdFd, KIOCSDIRECT, &tmp);
510: }
511: tmp = ((SunKbPrivPtr)pPriv->devPrivate)->trans;
512: (void)ioctl (kbdFd, KIOCTRANS, &tmp);
513: }
514:
515: if ( KbdOpenedHere )
516: (void) close( kbdFd );
517: return(0);
518:
519: bad:
520: if ( KbdOpenedHere )
521: (void) close( kbdFd );
522: return( -1 );
523: }
524:
525:
526: #ifdef SUN_WINDOWS
527:
528: /*-
529: *-----------------------------------------------------------------------
530: * sunSetUpKbdSunWin
531: * Change which events the kernel will pass through as keyboard
532: * events.
533: *
534: * Results:
535: *
536: * Side Effects:
537: *
538: *-----------------------------------------------------------------------
539: */
540:
541: Bool
542: sunSetUpKbdSunWin(windowFd, onoff, pKeyboard)
543: int windowFd;
544: Bool onoff;
545: DeviceRec *pKeyboard;
546: {
547: struct inputmask inputMask;
548: static struct inputmask oldInputMask;
549:
550: if (onoff) {
551: register int i;
552:
553: win_get_kbd_mask(windowFd, &oldInputMask);
554: input_imnull(&inputMask);
555: inputMask.im_flags |=
556: IM_ASCII | IM_NEGASCII |
557: IM_META | IM_NEGMETA |
558: IM_NEGEVENT | IM_INTRANSIT;
559: win_setinputcodebit(&inputMask, KBD_USE);
560: win_setinputcodebit(&inputMask, KBD_DONE);
561: win_setinputcodebit(&inputMask, SHIFT_CAPSLOCK);
562: win_setinputcodebit(&inputMask, SHIFT_LOCK);
563: win_setinputcodebit(&inputMask, SHIFT_LEFT);
564: win_setinputcodebit(&inputMask, SHIFT_RIGHT);
565: win_setinputcodebit(&inputMask, SHIFT_LEFTCTRL);
566: win_setinputcodebit(&inputMask, SHIFT_RIGHTCTRL);
567: win_setinputcodebit(&inputMask, SHIFT_META);
568: win_setinputcodebit(&inputMask, WIN_STOP);
569:
570: for (i=KEY_LEFTFIRST; i<=KEY_LEFTLAST; i++) {
571: win_setinputcodebit(&inputMask, i);
572: }
573: for (i=KEY_TOPFIRST; i<=KEY_TOPLAST; i++) {
574: win_setinputcodebit(&inputMask, i);
575: }
576: for (i=KEY_RIGHTFIRST; i<=KEY_RIGHTLAST; i++) {
577: win_setinputcodebit(&inputMask, i);
578: }
579:
580: win_set_kbd_mask(windowFd, &inputMask);
581:
582: /*
583: * Set the keyboard into "direct" mode and turn on
584: * event translation.
585: */
586: #ifdef notdef
587: if (sunChangeKbdTranslation(pKeyboard,TRUE) < 0) {
588: FatalError("Can't set keyboard translation\n");
589: }
590: #endif notdef
591: }
592: else {
593: win_set_kbd_mask(windowFd, &oldInputMask);
594:
595: /*
596: * Restore original keyboard directness and translation.
597: */
598: if (sunChangeKbdTranslation(pKeyboard,FALSE) < 0) {
599: FatalError("Can't reset keyboard translation\n");
600: }
601:
602: }
603: return (TRUE);
604: }
605:
606: #endif SUN_WINDOWS
607:
608:
609: #ifdef SUN_WINDOWS
610:
611: /*-
612: *-----------------------------------------------------------------------
613: * sunKbdProcessEventSunWin
614: * Process sunwindows event destined for the keyboard.
615: * Rather than replicate the logic (and therefore replicate
616: * bug fixes, etc), this code counterfeits a vuid
617: * Firm_event and then uses the non-sunwindows code.
618: *
619: * Results:
620: *
621: * Side Effects:
622: *
623: *-----------------------------------------------------------------------
624: */
625:
626: void
627: sunKbdProcessEventSunWin(pKeyboard,se)
628: DeviceRec *pKeyboard;
629: register struct inputevent *se;
630: {
631: Firm_event fe;
632:
633: fe.time = event_time(se);
634: fe.id = event_id(se);
635: fe.value = (event_is_up(se) ? VKEY_UP : VKEY_DOWN);
636:
637: sunKbdProcessEvent (pKeyboard, &fe);
638: }
639: #endif SUN_WINDOWS
640:
641:
642: Bool
643: LegalModifier(key)
644: {
645: return (TRUE);
646: }
647:
648: /*ARGSUSED*/
649: void
650: sunBlockHandler(nscreen, pbdata, pptv, pReadmask)
651: int nscreen;
652: pointer pbdata;
653: struct timeval **pptv;
654: pointer pReadmask;
655: {
656: static struct timeval artv; /* autorepeat timeval */
657: static sec1 = 0; /* tmp for patching */
658: static sec2 = AUTOREPEAT_INITIATE;
659: static sec3 = AUTOREPEAT_DELAY;
660:
661: if (!autoRepeatKeyDown)
662: return;
663:
664: artv.tv_sec = sec1;
665: if (autoRepeatFirst == TRUE)
666: artv.tv_usec = 1000 * sec2;
667: else
668: artv.tv_usec = 1000 * sec3;
669: *pptv = &artv;
670: if (autoRepeatDebug)
671: ErrorF("sunBlockHandler(%d,%d): \n", artv.tv_sec, artv.tv_usec);
672: }
673:
674: /*ARGSUSED*/
675: void
676: sunWakeupHandler(nscreen, pbdata, err, pReadmask)
677: int nscreen;
678: pointer pbdata;
679: unsigned long err;
680: pointer pReadmask;
681: {
682: struct timeval tv;
683:
684: if (autoRepeatDebug)
685: ErrorF("sunWakeupHandler(ar=%d, err=%d):\n", autoRepeatKeyDown, err);
686:
687: if (autoRepeatKeyDown) {
688: gettimeofday(&tv, (struct timezone *) NULL);
689: tvminus(autoRepeatDeltaTv, tv, autoRepeatLastKeyDownTv);
690: if (autoRepeatDeltaTv.tv_sec > 0 ||
691: (!autoRepeatFirst && autoRepeatDeltaTv.tv_usec >
692: 1000 * AUTOREPEAT_DELAY) ||
693: (autoRepeatDeltaTv.tv_usec >
694: 1000 * AUTOREPEAT_INITIATE))
695: autoRepeatReady++;
696: }
697:
698: if (autoRepeatReady)
699: ProcessInputEvents();
700: autoRepeatReady = 0;
701: }
702:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.