mirror of
https://github.com/Stichting-MINIX-Research-Foundation/xsrc.git
synced 2025-09-16 08:05:30 -04:00
400 lines
11 KiB
C
400 lines
11 KiB
C
/* $Xorg: sunMouse.c,v 1.3 2000/08/17 19:48:32 cpqbld Exp $ */
|
|
/*-
|
|
* Copyright 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 The Open Group
|
|
not be used in advertising or publicity pertaining to
|
|
distribution of the software without specific prior
|
|
written permission. Sun and The Open Group 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.
|
|
|
|
********************************************************/
|
|
/*
|
|
* Copyright 1991, 1992, 1993 Kaleb S. Keithley
|
|
*
|
|
* 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. Kaleb S. Keithley makes no
|
|
* representations about the suitability of this software for
|
|
* any purpose. It is provided "as is" without express or
|
|
* implied warranty.
|
|
*/
|
|
/* $XFree86: xc/programs/Xserver/hw/sun/sunMouse.c,v 1.4 2003/11/17 22:20:36 dawes Exp $ */
|
|
|
|
#define NEED_EVENTS
|
|
#include "sun.h"
|
|
#include "mi.h"
|
|
|
|
Bool sunActiveZaphod = TRUE;
|
|
|
|
static Bool sunCursorOffScreen();
|
|
static void sunCrossScreen();
|
|
static void sunWarpCursor();
|
|
|
|
miPointerScreenFuncRec sunPointerScreenFuncs = {
|
|
sunCursorOffScreen,
|
|
sunCrossScreen,
|
|
sunWarpCursor,
|
|
};
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* sunMouseCtrl --
|
|
* 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 sunMouseCtrl (
|
|
DeviceIntPtr device,
|
|
PtrCtrl* ctrl)
|
|
{
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* sunMouseProc --
|
|
* Handle the initialization, etc. of a mouse
|
|
*
|
|
* Results:
|
|
* none.
|
|
*
|
|
* Side Effects:
|
|
*
|
|
* Note:
|
|
* When using sunwindows, 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 sunKbdProc rather than in sunMouseProc.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
int sunMouseProc (
|
|
DeviceIntPtr device,
|
|
int what)
|
|
{
|
|
DevicePtr pMouse = (DevicePtr) device;
|
|
int format;
|
|
static int oformat;
|
|
BYTE map[4];
|
|
|
|
switch (what) {
|
|
case DEVICE_INIT:
|
|
if (pMouse != LookupPointerDevice()) {
|
|
ErrorF ("Cannot open non-system mouse");
|
|
return !Success;
|
|
}
|
|
if (sunPtrPriv.fd == -1)
|
|
return !Success;
|
|
pMouse->devicePrivate = (pointer) &sunPtrPriv;
|
|
pMouse->on = FALSE;
|
|
map[1] = 1;
|
|
map[2] = 2;
|
|
map[3] = 3;
|
|
InitPointerDeviceStruct(
|
|
pMouse, map, 3, miPointerGetMotionEvents,
|
|
sunMouseCtrl, miPointerGetMotionBufferSize());
|
|
break;
|
|
|
|
case DEVICE_ON:
|
|
if (ioctl (sunPtrPriv.fd, VUIDGFORMAT, &oformat) == -1) {
|
|
Error ("sunMouseProc ioctl VUIDGFORMAT");
|
|
return !Success;
|
|
}
|
|
format = VUID_FIRM_EVENT;
|
|
if (ioctl (sunPtrPriv.fd, VUIDSFORMAT, &format) == -1) {
|
|
Error ("sunMouseProc ioctl VUIDSFORMAT");
|
|
return !Success;
|
|
}
|
|
sunPtrPriv.bmask = 0;
|
|
AddEnabledDevice (sunPtrPriv.fd);
|
|
pMouse->on = TRUE;
|
|
break;
|
|
|
|
case DEVICE_CLOSE:
|
|
pMouse->on = FALSE;
|
|
if (ioctl (sunPtrPriv.fd, VUIDSFORMAT, &oformat) == -1)
|
|
Error ("sunMouseProc ioctl VUIDSFORMAT");
|
|
break;
|
|
|
|
case DEVICE_OFF:
|
|
pMouse->on = FALSE;
|
|
RemoveEnabledDevice (sunPtrPriv.fd);
|
|
break;
|
|
}
|
|
return Success;
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* sunMouseGetEvents --
|
|
* Return the events waiting in the wings for the given mouse.
|
|
*
|
|
* Results:
|
|
* A pointer to an array of Firm_events or (Firm_event *)0 if no events
|
|
* The number of events contained in the array.
|
|
* A boolean as to whether more events might be available.
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
|
|
Firm_event* sunMouseGetEvents (
|
|
int fd,
|
|
Bool on,
|
|
int* pNumEvents,
|
|
Bool* pAgain)
|
|
{
|
|
int nBytes; /* number of bytes of events available. */
|
|
static Firm_event evBuf[MAXEVENTS]; /* Buffer for Firm_events */
|
|
|
|
if ((nBytes = read (fd, (char *)evBuf, sizeof(evBuf))) == -1) {
|
|
if (errno == EWOULDBLOCK) {
|
|
*pNumEvents = 0;
|
|
*pAgain = FALSE;
|
|
} else {
|
|
Error ("sunMouseGetEvents read");
|
|
FatalError ("Could not read from mouse");
|
|
}
|
|
} else {
|
|
if (on) {
|
|
*pNumEvents = nBytes / sizeof (Firm_event);
|
|
*pAgain = (nBytes == sizeof (evBuf));
|
|
} else {
|
|
*pNumEvents = 0;
|
|
*pAgain = FALSE;
|
|
}
|
|
}
|
|
return evBuf;
|
|
}
|
|
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* MouseAccelerate --
|
|
* Given a delta and a mouse, return the acceleration of the delta.
|
|
*
|
|
* Results:
|
|
* The corrected delta
|
|
*
|
|
* Side Effects:
|
|
* None.
|
|
*
|
|
*-----------------------------------------------------------------------
|
|
*/
|
|
static short
|
|
MouseAccelerate (device, delta)
|
|
DeviceIntPtr device;
|
|
int delta;
|
|
{
|
|
int sgn = sign(delta);
|
|
PtrCtrl *pCtrl;
|
|
short ret;
|
|
|
|
delta = abs(delta);
|
|
pCtrl = &device->ptrfeed->ctrl;
|
|
if (delta > pCtrl->threshold) {
|
|
ret =
|
|
(short) sgn *
|
|
(pCtrl->threshold + ((delta - pCtrl->threshold) * pCtrl->num) /
|
|
pCtrl->den);
|
|
} else {
|
|
ret = (short) sgn * delta;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*-
|
|
*-----------------------------------------------------------------------
|
|
* sunMouseEnqueueEvent --
|
|
* 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 sunMouseEnqueueEvent (
|
|
DeviceIntPtr device,
|
|
Firm_event *fe)
|
|
{
|
|
xEvent xE;
|
|
sunPtrPrivPtr pPriv; /* Private data for pointer */
|
|
int bmask; /* Temporary button mask */
|
|
unsigned long time;
|
|
int x, y;
|
|
|
|
pPriv = (sunPtrPrivPtr)device->public.devicePrivate;
|
|
|
|
time = xE.u.keyButtonPointer.time = TVTOMILLI(fe->time);
|
|
|
|
switch (fe->id) {
|
|
case MS_LEFT:
|
|
case MS_MIDDLE:
|
|
case MS_RIGHT:
|
|
/*
|
|
* 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 = (fe->id - MS_LEFT) + 1;
|
|
bmask = 1 << xE.u.u.detail;
|
|
if (fe->value == VKEY_UP) {
|
|
if (pPriv->bmask & bmask) {
|
|
xE.u.u.type = ButtonRelease;
|
|
pPriv->bmask &= ~bmask;
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
if ((pPriv->bmask & bmask) == 0) {
|
|
xE.u.u.type = ButtonPress;
|
|
pPriv->bmask |= bmask;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
mieqEnqueue (&xE);
|
|
break;
|
|
case LOC_X_DELTA:
|
|
miPointerDeltaCursor (MouseAccelerate(device,fe->value),0,time);
|
|
break;
|
|
case LOC_Y_DELTA:
|
|
/*
|
|
* For some reason, motion up generates a positive y delta
|
|
* and motion down a negative delta, so we must subtract
|
|
* here instead of add...
|
|
*/
|
|
miPointerDeltaCursor (0,-MouseAccelerate(device,fe->value),time);
|
|
break;
|
|
case LOC_X_ABSOLUTE:
|
|
miPointerPosition (&x, &y);
|
|
miPointerAbsoluteCursor (fe->value, y, time);
|
|
break;
|
|
case LOC_Y_ABSOLUTE:
|
|
miPointerPosition (&x, &y);
|
|
miPointerAbsoluteCursor (x, fe->value, time);
|
|
break;
|
|
default:
|
|
FatalError ("sunMouseEnqueueEvent: unrecognized id\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static Bool
|
|
sunCursorOffScreen (pScreen, x, y)
|
|
ScreenPtr *pScreen;
|
|
int *x, *y;
|
|
{
|
|
int index, ret = FALSE;
|
|
extern Bool PointerConfinedToScreen();
|
|
|
|
if (PointerConfinedToScreen()) return TRUE;
|
|
/*
|
|
* Active Zaphod implementation:
|
|
* increment or decrement the current screen
|
|
* if the x is to the right or the left of
|
|
* the current screen.
|
|
*/
|
|
if (sunActiveZaphod &&
|
|
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];
|
|
}
|
|
ret = TRUE;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
sunCrossScreen (pScreen, entering)
|
|
ScreenPtr pScreen;
|
|
Bool entering;
|
|
{
|
|
if (sunFbs[pScreen->myNum].EnterLeave)
|
|
(*sunFbs[pScreen->myNum].EnterLeave) (pScreen, entering ? 0 : 1);
|
|
}
|
|
|
|
static void
|
|
sunWarpCursor (pScreen, x, y)
|
|
ScreenPtr pScreen;
|
|
int x, y;
|
|
{
|
|
#ifndef i386
|
|
sigset_t newsigmask;
|
|
|
|
(void) sigemptyset (&newsigmask);
|
|
#ifdef SVR4
|
|
(void) sigaddset (&newsigmask, SIGPOLL);
|
|
#else
|
|
(void) sigaddset (&newsigmask, SIGIO);
|
|
#endif
|
|
(void) sigprocmask (SIG_BLOCK, &newsigmask, (sigset_t *)NULL);
|
|
miPointerWarpCursor (pScreen, x, y);
|
|
(void) sigprocmask (SIG_UNBLOCK, &newsigmask, (sigset_t *)NULL);
|
|
#else
|
|
int oldmask;
|
|
|
|
oldmask = sigblock (sigmask (SIGIO));
|
|
miPointerWarpCursor (pScreen, x, y);
|
|
sigsetmask (oldmask);
|
|
#endif
|
|
}
|