Path: utzoo!utgpu!cs.utexas.edu!swrinde!ucsd!rutgers!aramis.rutgers.edu!paul.rutgers.edu!chain From: chain@paul.rutgers.edu (Chain Lee) Newsgroups: alt.sources Subject: X11R4 patch for SCO XENIX (part02) Message-ID: Date: 7 Jan 91 02:22:13 GMT Organization: Rutgers Univ., New Brunswick, N.J. Lines: 990 *** X11R4.ORIG/mit/server/ddx/xenix/vga/kbd_mode.c Sun Jan 6 01:03:01 1991 --- X11R4/mit/server/ddx/xenix/vga/kbd_mode.c Sat Jan 5 17:50:19 1991 *************** *** 0 **** --- 1,107 ---- + /* + * kbd_mode.c Modified for Xenix by Chain Lee 08/90 + */ + + /************************************************************ + Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA. + + All Rights Reserved + + Permission to use, copy, modify, and distribute this + software and its documentation for any purpose and without + fee is hereby granted, provided that the above copyright no- + tice appear in all copies and that both that copyright no- + tice and this permission notice appear in supporting docu- + mentation, and that the names of Sun or MIT not be used in + advertising or publicity pertaining to distribution of the + software without specific prior written permission. Sun and + M.I.T. make no representations about the suitability of this + software for any purpose. It is provided "as is" without any + express or implied warranty. + + SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT- + NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI- + ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR + ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH + THE USE OR PERFORMANCE OF THIS SOFTWARE. + + ********************************************************/ + + #ifndef lint + static char sccsid[] = "@(#)kbd_mode.c 7.1 87/04/13"; + #endif + + /* + * Copyright (c) 1986 by Sun Microsystems, Inc. + * + * kbd_mode: set keyboard encoding mode + */ + + #include + #include + #include + #include + + static void die(), usage(); + static int kbd_fd=0; + + main(argc, argv) + int argc; + char *argv[]; + { + int code, translate; + + argc--; + argv++; + if (argc-- && **argv == '-') { + code = *(++*argv); + } else { + usage(); + } + switch (code) { + case 'a': + case 'A': + translate = K_XLATE; + break; + case 'r': + case 'R': + translate = K_RAW; + break; + default: + usage(); + } + if (ioctl(kbd_fd, KDSKBMODE, translate)) { + die("Couldn't initialize translation to Event"); + } + exit(0); + } + + static void + die(msg) + char *msg; + { + fprintf(stderr, "%s\n", msg); + exit(1); + } + + static void + usage() + { + int translate; + #if XENIX_HAS_NO_BUGS + if ((translate = ioctl(kbd_fd, KDGKBMODE, &translate)) == -1) { + die("Couldn't inquire current translation"); + } + #endif + fprintf(stderr, "kbd_mode { -a | -r }\n"); + fprintf(stderr, "\tfor ascii, or raw event.\n"); + fprintf(stderr, "Current mode is %s.\n", + ( translate == K_XLATE ? "a (ascii bytes)" : + ( translate == K_RAW ? "r (raw events)" : "unknown mode"))); + exit(1); + } + + *** X11R4.ORIG/mit/server/ddx/xenix/vga/xenixKbd.c Sun Jan 6 01:03:03 1991 --- X11R4/mit/server/ddx/xenix/vga/xenixKbd.c Mon Dec 10 00:26:22 1990 *************** *** 0 **** --- 1,500 ---- + /* + * xenixKbd.c Modified for Xenix by Chain Lee 08/90 + */ + + /*- + * + * Copyright (c) 1987 by the Regents of the University of California + * + * Permission to use, copy, modify, and distribute this + * software and its documentation for any purpose and without + * fee is hereby granted, provided that the above copyright + * notice appear in all copies. The University of California + * makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without + * express or implied warranty. + * + */ + + /************************************************************ + Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA. + + All Rights Reserved + + Permission to use, copy, modify, and distribute this + software and its documentation for any purpose and without + fee is hereby granted, provided that the above copyright no- + tice appear in all copies and that both that copyright no- + tice and this permission notice appear in supporting docu- + mentation, and that the names of Sun or MIT not be used in + advertising or publicity pertaining to distribution of the + software without specific prior written permission. Sun and + M.I.T. make no representations about the suitability of this + software for any purpose. It is provided "as is" without any + express or implied warranty. + + SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT- + NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI- + ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR + ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH + THE USE OR PERFORMANCE OF THIS SOFTWARE. + + ********************************************************/ + + #define NEED_EVENTS + #include "xenix.h" + #include "Xproto.h" + #include "keysym.h" + #include "inputstr.h" + + typedef struct { + int trans; /* Original translation form */ + } SunKbPrivRec, *SunKbPrivPtr; + + extern CARD8 *xenixModMap[]; + extern CARD8 ibmAT101ModMap[]; + extern KeySymsRec xenixKeySyms[]; + + extern CARD8 keyCodePrefix1, keyCodePrefix2, keyCodeCapsLock; + + extern void ProcessInputEvents(); + extern void miPointerPosition(); + + static void xenixBell(); + static void xenixKbdCtrl(); + void xenixKbdProcessEvent(); + static void xenixKbdDoneEvents(); + + int click = 0; + + int autoRepeatKeyDown = 0; + int autoRepeatDebug = 0; + int autoRepeatReady; + long autoRepeatInitiate = 1000 * AUTOREPEAT_INITIATE; + long autoRepeatDelay = 1000 * AUTOREPEAT_DELAY; + static int autoRepeatFirst; + struct timeval autoRepeatLastKeyDownTv; + struct timeval autoRepeatDeltaTv; + + static KeybdCtrl sysKbCtrl; + + static KbPrivRec sysKbPriv = { + -1, /* Type of keyboard */ + xenixKbdProcessEvent, /* Function to process an event */ + xenixKbdDoneEvents, /* Function called when all events */ + /* have been handled. */ + (pointer) NULL, /* Private to keyboard device */ + 0, /* offset for device keycodes */ + &sysKbCtrl, /* Initial full duration = .20 sec. */ + }; + + static void + sigsegv(){ + reset_tty(0); + ev_close(); + abort(); + } + + /*- + *----------------------------------------------------------------------- + * xenixKbdProc -- + * Handle the initialization, etc. of a keyboard. + * + * Results: + * None. + * + * Side Effects: + * + * Note: + * When using xenixwindows, all input comes off a single fd, stored in the + * global windowFd. Therefore, only one device should be enabled and + * disabled, even though the application still sees both mouse and + * keyboard. We have arbitrarily chosen to enable and disable windowFd + * in the keyboard routine xenixKbdProc rather than in xenixMouseProc. + * + *----------------------------------------------------------------------- + */ + int + xenixKbdProc (pKeyboard, what) + DevicePtr pKeyboard; /* Keyboard to manipulate */ + int what; /* What to do to it */ + { + int qfd; + dmask_t dmask = D_STRING | D_REL | D_BUTTON; + static int kbdFd=0; + + switch (what) { + case DEVICE_INIT: + + signal(SIGSEGV, sigsegv); + + if (pKeyboard != LookupKeyboardDevice()) { + ErrorF ("Cannot open non-system keyboard"); + return (!Success); + } + + /* + * First open the event manager. + */ + if (ev_init() < 0) { + ErrorF("xenixKbdProc: cannot init event manager\n"); + return (!Success); + } + if ((qfd = ev_open(&dmask)) < 0) { + ErrorF("xenixKbdProc: cannot open event manager\n"); + return (!Success); + } + if (dmask != (D_STRING | D_REL | D_BUTTON)) { + Error("xenixKbdProc: cannot attach mouse and keyboard\n"); + return (!Success); + } + + pKeyboard->devicePrivate = (pointer)&sysKbPriv; + pKeyboard->on = FALSE; + sysKbCtrl = defaultKeyboardControl; + sysKbPriv.ctrl = &sysKbCtrl; + + sysKbPriv.type = KBTYPE_IBMAT; + if (xenixKeySyms[sysKbPriv.type].minKeyCode < MIN_KEYCODE) { + int offset=MIN_KEYCODE-xenixKeySyms[sysKbPriv.type].minKeyCode; + + xenixKeySyms[sysKbPriv.type].minKeyCode += offset; + xenixKeySyms[sysKbPriv.type].maxKeyCode += offset; + sysKbPriv.offset = offset; + } + + /* set up keyboard for raw event generating mode */ + /* set up tty to raw mode */ + set_tty(0); + + InitKeyboardDeviceStruct( + pKeyboard, + &(xenixKeySyms[sysKbPriv.type]), + (xenixModMap[sysKbPriv.type]), + xenixBell, + xenixKbdCtrl); + break; + + case DEVICE_ON: + /* AddEnabledDevice(windowFd); + */ pKeyboard->on = TRUE; + break; + + case DEVICE_OFF: + /* RemoveEnabledDevice(kbdFd); + */ pKeyboard->on = FALSE; + break; + case DEVICE_CLOSE: + /* RemoveEnabledDevice(kbdFd); + */ pKeyboard->on = FALSE; + reset_tty(0); + ev_close(); + break; + } + return (Success); + } + + /*- + *----------------------------------------------------------------------- + * xenixBell -- + * Ring the terminal/keyboard bell + * + * Results: + * Ring the keyboard bell for an amount of time proportional to + * "loudness." + * + * Side Effects: + * None, really... + * + *----------------------------------------------------------------------- + */ + static void + xenixBell (loudness, pKeyboard) + int loudness; /* Percentage of full volume */ + DevicePtr pKeyboard; /* Keyboard to ring */ + { + static int bell_fd = -1; + + if (loudness == 0) { + return; + } + if (bell_fd < 0) + if ((bell_fd = open("/dev/bell", O_RDWR, 0)) < 0) { + ErrorF("xenixBell: cannot \"/dev/bell\"\n"); + return; + } + write(bell_fd, "\002", 1 ); + nap(loudness); + write(bell_fd,"\003",1); + } + + /*- + *----------------------------------------------------------------------- + * xenixKbdCtrl -- + * Alter some of the keyboard control parameters + * + * Results: + * None. + * + * Side Effects: + * Some... + * + *----------------------------------------------------------------------- + */ + static void + xenixKbdCtrl (pKeyboard, ctrl) + DevicePtr pKeyboard; /* Keyboard to alter */ + KeybdCtrl *ctrl; + { + /* LEDS */ + ioctl(0, KDSETLED, ctrl->leds); + /* keyboard click */ + click = ctrl->click; + } + + + /*- + *----------------------------------------------------------------------- + * xenixKbdProcessEvent -- + * + * Results: + * + * Side Effects: + * + * Caveat: + * To reduce duplication of code and logic (and therefore bugs), the + * xenixwindows version of kbd processing (xenixKbdProcessEventSunWin()) + * counterfeits a firm event and calls this routine. This + * couunterfeiting relies on the fact this this routine only looks at the + * id, time, and value fields of the firm event which it is passed. If + * this ever changes, the xenixKbdProcessEventSunWin will also have to + * change. + * + *----------------------------------------------------------------------- + */ + void + xenixKbdProcessEvent (pKeyboard, evp) + DevicePtr pKeyboard; + EVENT *evp; + { + xEvent xE; + int delta; + static xEvent autoRepeatEvent; + BYTE key; + CARD8 keyModifiers; + + /* we need to encode three states of the cap lock key */ + static int capsLockDown = 0; + static int capsLockOn = 0; + + #if OK + if (autoRepeatKeyDown && fe->id == AUTOREPEAT_EVENTID) { + pPriv = (KbPrivPtr) pKeyboard->devicePrivate; + if (pPriv->ctrl->autoRepeat != AutoRepeatModeOn) { + autoRepeatKeyDown = 0; + return; + } + /* + * Generate auto repeat event. XXX one for now. + * Update time & pointer location of saved KeyPress event. + */ + if (autoRepeatDebug) + ErrorF("xenixKbdProcessEvent: autoRepeatKeyDown = %d\n", + autoRepeatKeyDown); + + delta = TVTOMILLI(autoRepeatDeltaTv); + autoRepeatFirst = FALSE; + + /* + * Fake a key up event and a key down event + * for the last key pressed. + */ + autoRepeatEvent.u.keyButtonPointer.time += delta; + miPointerPosition (screenInfo.screens[0], + &autoRepeatEvent.u.keyButtonPointer.rootX, + &autoRepeatEvent.u.keyButtonPointer.rootY); + autoRepeatEvent.u.u.type = KeyRelease; + (* pKeyboard->processInputProc) (&autoRepeatEvent, pKeyboard, 1); + + autoRepeatEvent.u.u.type = KeyPress; + (* pKeyboard->processInputProc) (&autoRepeatEvent, pKeyboard, 1); + + /* Update time of last key down */ + tvplus(autoRepeatLastKeyDownTv, autoRepeatLastKeyDownTv, + autoRepeatDeltaTv); + + return; + } + #endif + + key = EV_BUF(*evp)[0]; + + /* caps lock flip flop */ + if (key == (0x80 | keyCodeCapsLock)) { + capsLockDown = 0; + return; + } + + if (key == keyCodeCapsLock) { + if (capsLockDown) + return; + else + capsLockDown = 1; + + if (capsLockOn) { + EV_BUF(*evp)[0] |= 0x80; + capsLockOn = 0; + } + else + { + capsLockOn = 1; + } + } + + /* keyboard click */ + if (!(key & 0x80)) + if (click >= 0) + xenixBell(click, pKeyboard); + + key &= 0x7f; + + /* + keyModifiers = ((DeviceIntPtr)pKeyboard)->key->modifierMap[key]; + */ + keyModifiers = ibmAT101ModMap[key]; + key += sysKbPriv.offset; + + if (autoRepeatKeyDown && (keyModifiers == 0) && + (!(EV_BUF(*evp)[0] & 0x80) || (key == autoRepeatEvent.u.u.detail))) { + /* + * Kill AutoRepeater on any real non-modifier key down, or auto key up + */ + autoRepeatKeyDown = 0; + if (autoRepeatDebug) + ErrorF("xenixKbdProcessEvent: autoRepeat off\n"); + } + + xE.u.keyButtonPointer.time = EV_TIME(*evp); + miPointerPosition (screenInfo.screens[0], + &xE.u.keyButtonPointer.rootX, + &xE.u.keyButtonPointer.rootY); + xE.u.u.type = ((EV_BUF(*evp)[0] & 0x80) ? KeyRelease : KeyPress); + xE.u.u.detail = key; + + #if OK + if (keyModifiers & LockMask) { + if (xE.u.u.type == KeyRelease) + return; /* this assumes autorepeat is not desired */ + if (BitIsOn(((DeviceIntPtr)pKeyboard)->key->down, key)) + xE.u.u.type = KeyRelease; + } + + if ((xE.u.u.type == KeyPress) && (keyModifiers == 0)) { + /* initialize new AutoRepeater event & mark AutoRepeater on */ + if (autoRepeatDebug) + ErrorF("xenixKbdProcessEvent: VKEY_DOWN\n"); + autoRepeatEvent = xE; + autoRepeatFirst = TRUE; + autoRepeatKeyDown++; + autoRepeatLastKeyDownTv = EV_TIME(*evp); + } + #endif + (* pKeyboard->processInputProc) (&xE, pKeyboard, 1); + } + + /*- + *----------------------------------------------------------------------- + * xenixDoneEvents -- + * Nothing to do, here... + * + * Results: + * + * Side Effects: + * + *----------------------------------------------------------------------- + */ + /*ARGSUSED*/ + static void + xenixKbdDoneEvents (pKeyboard) + DevicePtr pKeyboard; + { + + } + + /*ARGSUSED*/ + Bool + LegalModifier(key) + { + return (TRUE); + } + + static KeybdCtrl *pKbdCtrl = (KeybdCtrl *) 0; + + /*ARGSUSED*/ + void + xenixBlockHandler(nscreen, pbdata, pptv, pReadmask) + int nscreen; + pointer pbdata; + struct timeval **pptv; + pointer pReadmask; + { + static struct timeval artv = { 0, 0 }; /* autorepeat timeval */ + #if OK + if (!autoRepeatKeyDown) + return; + + if (pKbdCtrl == (KeybdCtrl *) 0) + pKbdCtrl = ((KbPrivPtr) LookupKeyboardDevice()->devicePrivate)->ctrl; + + if (pKbdCtrl->autoRepeat != AutoRepeatModeOn) + return; + + if (autoRepeatFirst == TRUE) + artv.tv_usec = autoRepeatInitiate; + else + artv.tv_usec = autoRepeatDelay; + *pptv = &artv; + + if (autoRepeatDebug) + ErrorF("xenixBlockHandler(%d,%d): \n", artv.tv_sec, artv.tv_usec); + #endif + } + + /*ARGSUSED*/ + void + xenixWakeupHandler(nscreen, pbdata, err, pReadmask) + int nscreen; + pointer pbdata; + unsigned long err; + pointer pReadmask; + { + struct timeval tv; + #if OK + if (autoRepeatDebug) + ErrorF("xenixWakeupHandler(ar=%d, err=%d):\n", autoRepeatKeyDown, err); + + if (pKbdCtrl == (KeybdCtrl *) 0) + pKbdCtrl = ((KbPrivPtr) LookupKeyboardDevice()->devicePrivate)->ctrl; + + if (pKbdCtrl->autoRepeat != AutoRepeatModeOn) + return; + + if (autoRepeatKeyDown) { + gettimeofday(&tv, (struct timezone *) NULL); + tvminus(autoRepeatDeltaTv, tv, autoRepeatLastKeyDownTv); + if (autoRepeatDeltaTv.tv_sec > 0 || + (!autoRepeatFirst && autoRepeatDeltaTv.tv_usec > + autoRepeatDelay) || + (autoRepeatDeltaTv.tv_usec > + autoRepeatInitiate)) + autoRepeatReady++; + } + + if (autoRepeatReady) + ProcessInputEvents(); + autoRepeatReady = 0; + #endif + } *** X11R4.ORIG/mit/server/ddx/xenix/vga/xenixMouse.c Sun Jan 6 01:03:07 1991 --- X11R4/mit/server/ddx/xenix/vga/xenixMouse.c Mon Dec 10 00:31:49 1990 *************** *** 0 **** --- 1,367 ---- + /* + * xenixMouse.c Modified for Xenix by Chain Lee 08/90 + */ + + /*- + * sunMouse.c -- + * Functions for playing cat and mouse... sorry. + * + * Copyright (c) 1987 by the Regents of the University of California + * + * Permission to use, copy, modify, and distribute this + * software and its documentation for any purpose and without + * fee is hereby granted, provided that the above copyright + * notice appear in all copies. The University of California + * makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without + * express or implied warranty. + * + * + */ + + /************************************************************ + Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA. + + All Rights Reserved + + Permission to use, copy, modify, and distribute this + software and its documentation for any purpose and without + fee is hereby granted, provided that the above copyright no- + tice appear in all copies and that both that copyright no- + tice and this permission notice appear in supporting docu- + mentation, and that the names of Sun or MIT not be used in + advertising or publicity pertaining to distribution of the + software without specific prior written permission. Sun and + M.I.T. make no representations about the suitability of this + software for any purpose. It is provided "as is" without any + express or implied warranty. + + SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT- + NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI- + ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR + ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH + THE USE OR PERFORMANCE OF THIS SOFTWARE. + + ********************************************************/ + + #define NEED_EVENTS + + #include "xenix.h" + #include "mipointer.h" + #include "misprite.h" + + #define ABS(a) (((a)>0)?(a):-(a)) + + Bool ActiveZaphod = TRUE; + + extern void xenixSuspendX(); + + static long xenixEventTime(); + static Bool xenixCursorOffScreen(); + static void xenixCrossScreen(); + extern void miPointerQueueEvent(); + + miPointerCursorFuncRec xenixPointerCursorFuncs = { + xenixEventTime, + xenixCursorOffScreen, + xenixCrossScreen, + miPointerQueueEvent, + }; + + typedef struct { + int bmask; /* Current button state */ + Bool mouseMoved; /* Mouse has moved */ + } XenixMsPrivRec, *XenixMsPrivPtr; + + static void xenixMouseCtrl(); + static int xenixMouseGetMotionEvents(); + void xenixMouseProcessEvent(); + static void xenixMouseDoneEvents(); + + static XenixMsPrivRec xenixMousePriv; + static PtrPrivRec sysMousePriv = { + xenixMouseProcessEvent, /* Function to process an event */ + xenixMouseDoneEvents, /* When all the events have been */ + /* handled, this function will be */ + /* called. */ + 0, /* Current X coordinate of pointer */ + 0, /* Current Y coordinate */ + (pointer)&xenixMousePriv, /* Field private to device */ + }; + + /*- + *----------------------------------------------------------------------- + * xenixMouseProc -- + * Handle the initialization, etc. of a mouse + * + * Results: + * none. + * + * Side Effects: + * + * Note: + * When using xenixwindows, all input comes off a single fd, stored in the + * global windowFd. Therefore, only one device should be enabled and + * disabled, even though the application still sees both mouse and + * keyboard. We have arbitrarily chosen to enable and disable windowFd + * in the keyboard routine xenixKbdProc rather than in xenixMouseProc. + * + *----------------------------------------------------------------------- + */ + int + xenixMouseProc (pMouse, what) + DevicePtr pMouse; /* Mouse to play with */ + int what; /* What to do with it */ + { + register int fd; + int format; + static int oformat; + BYTE map[4]; + + switch (what) { + case DEVICE_INIT: + if (pMouse != LookupPointerDevice()) { + ErrorF ("Cannot open non-system mouse"); + return (!Success); + } + + sysMousePriv.x = 0; + sysMousePriv.y = 0; + + xenixMousePriv.mouseMoved = FALSE; + pMouse->devicePrivate = (pointer) &sysMousePriv; + + pMouse->on = FALSE; + map[1] = 1; + map[2] = 2; + map[3] = 3; + InitPointerDeviceStruct( + pMouse, map, 3, xenixMouseGetMotionEvents, xenixMouseCtrl, 0); + break; + + case DEVICE_ON: + + /* AddEnabledDevice (((PtrPrivPtr)pMouse->devicePrivate)->fd); + */ + pMouse->on = TRUE; + break; + + case DEVICE_CLOSE: + break; + + case DEVICE_OFF: + /* RemoveEnabledDevice (((PtrPrivPtr)pMouse->devicePrivate)->fd); + */ pMouse->on = FALSE; + break; + } + return (Success); + } + + /*- + *----------------------------------------------------------------------- + * xenixMouseCtrl -- + * Alter the control parameters for the mouse. Since acceleration + * etc. is done from the PtrCtrl record in the mouse's device record, + * there's nothing to do here. + * + * Results: + * None. + * + * Side Effects: + * None. + * + *----------------------------------------------------------------------- + */ + /*ARGSUSED*/ + static void + xenixMouseCtrl (pMouse) + DevicePtr pMouse; + { + } + + /*- + *----------------------------------------------------------------------- + * xenixMouseGetMotionEvents -- + * Return the (number of) motion events in the "motion history + * buffer" (snicker) between the given times. + * + * Results: + * The number of events stuffed. + * + * Side Effects: + * The relevant xTimecoord's are stuffed in the passed memory. + * + *----------------------------------------------------------------------- + */ + /*ARGSUSED*/ + static int + xenixMouseGetMotionEvents (buff, start, stop, pScreen) + CARD32 start, stop; + xTimecoord *buff; + ScreenPtr pScreen; + { + return 0; + } + + + /*- + *----------------------------------------------------------------------- + * xenixMouseProcessEvent -- + * Given a Firm_event for a mouse, pass it off the the dix layer + * properly converted... + * + * Results: + * None. + * + * Side Effects: + * The cursor may be redrawn...? devPrivate/x/y will be altered. + * + *----------------------------------------------------------------------- + */ + void + xenixMouseProcessEvent (pMouse, evp) + DevicePtr pMouse; /* Mouse from which the event came */ + EVENT *evp; /* Event to process */ + { + xEvent xE; + register XenixMsPrivPtr pXenixPriv; /* Private data for mouse */ + static int button = 0; /* previous button state */ + int b; /* current button state */ + int bKey; /* button value expected by X */ + static int mouseMoved = 0; + + + xE.u.keyButtonPointer.time = EV_TIME(*evp); + + if (EV_TAG(*evp) & T_BUTTON) { + b = EV_BUTTONS(*evp); + + if (b == 7) { + xenixSuspendX(); + return; + } + switch (ABS(b - button)) { + case LT_BUTTON: bKey = 1; break; + case MD_BUTTON: bKey = 2; break; + case RT_BUTTON: bKey = 3; break; + default: return; + } + /* + * A button changed state. Sometimes we will get two events + * for a single state change. Should we get a button event which + * reflects the current state of affairs, that event is discarded. + * + * Mouse buttons start at 1. + */ + xE.u.u.detail = bKey; + if (button - b > 0) + xE.u.u.type = ButtonRelease; + else + xE.u.u.type = ButtonPress; + button = b; + + /* + * If the mouse has moved, we must update any interested client + * as well as DIX before sending a button event along. + */ + if (mouseMoved) { + xenixMouseDoneEvents (pMouse, FALSE); + } + + miPointerPosition (screenInfo.screens[0], + &xE.u.keyButtonPointer.rootX, + &xE.u.keyButtonPointer.rootY); + + (* pMouse->processInputProc) (&xE, pMouse, 1); + } + if (EV_TAG(*evp) & T_REL_LOCATOR) { + miPointerDeltaCursor (screenInfo.screens[0], + EV_DX(*evp), + -EV_DY(*evp), + TRUE); + } + } + + /*ARGSUSED*/ + static Bool + xenixCursorOffScreen (pScreen, x, y) + ScreenPtr *pScreen; + int *x, *y; + { + int index; + + /* + * Active Zaphod implementation: + * increment or decrement the current screen + * if the x is to the right or the left of + * the current screen. + */ + if (ActiveZaphod && + screenInfo.numScreens > 1 && (*x >= (*pScreen)->width || *x < 0)) + { + index = (*pScreen)->myNum; + if (*x < 0) + { + index = (index ? index : screenInfo.numScreens) - 1; + *pScreen = screenInfo.screens[index]; + *x += (*pScreen)->width; + } + else + { + *x -= (*pScreen)->width; + index = (index + 1) % screenInfo.numScreens; + *pScreen = screenInfo.screens[index]; + } + return TRUE; + } + return FALSE; + } + + /*ARGSUSED*/ + static long + xenixEventTime (pScreen) + ScreenPtr pScreen; + { + return lastEventTime; + } + + static void + xenixCrossScreen (pScreen, entering) + ScreenPtr pScreen; + Bool entering; + { + uchar_t select; + + select = 1; + if (entering) + select = 0; + if (xenixFbs[pScreen->myNum].EnterLeave) + (*xenixFbs[pScreen->myNum].EnterLeave) (pScreen, select); + } + + /*- + *----------------------------------------------------------------------- + * xenixMouseDoneEvents -- + * Finish off any mouse motions we haven't done yet. (At the moment + * this code is unused since we never save mouse motions as I'm + * unsure of the effect of getting a keystroke at a given [x,y] w/o + * having gotten a motion event to that [x,y]) + * + * Results: + * None. + * + * Side Effects: + * A MotionNotify event may be generated. + * + *----------------------------------------------------------------------- + */ + /*ARGSUSED*/ + static void + xenixMouseDoneEvents (pMouse,final) + DevicePtr pMouse; + Bool final; + { + }