266 lines
6.6 KiB
C
266 lines
6.6 KiB
C
/* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/sco/sco_mouse.c,v 3.13 2002/11/20 23:07:50 dawes Exp $ */
|
|
/*
|
|
* Copyright 2001 by J. Kean Johnston <jkj@sco.com>
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name J. Kean Johnston not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. J. Kean Johnston makes no
|
|
* representations about the suitability of this software for any purpose.
|
|
* It is provided "as is" without express or implied warranty.
|
|
*
|
|
* J. KEAN JOHNSTON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
* EVENT SHALL J. KEAN JOHNSTON BE LIABLE 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.
|
|
*/
|
|
|
|
/* $XConsortium$ */
|
|
|
|
#include "X.h"
|
|
#include "compiler.h"
|
|
|
|
#include "xf86.h"
|
|
#include "xf86Priv.h"
|
|
#include "xf86_OSlib.h"
|
|
#include "xf86Xinput.h"
|
|
#include "xf86OSmouse.h"
|
|
#include "mipointer.h"
|
|
#include <sys/event.h>
|
|
#include <mouse.h>
|
|
|
|
static int
|
|
SupportedInterfaces (void)
|
|
{
|
|
/* FIXME: Is this correct? Should we just return MSE_MISC? */
|
|
return MSE_SERIAL | MSE_BUS | MSE_PS2 | MSE_XPS2 | MSE_MISC | MSE_AUTO;
|
|
}
|
|
|
|
static const char *internalNames[] = {
|
|
"OSMouse",
|
|
NULL
|
|
};
|
|
|
|
static const char **
|
|
BuiltinNames (void)
|
|
{
|
|
return internalNames;
|
|
}
|
|
|
|
static Bool
|
|
CheckProtocol (const char *protocol)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; internalNames[i]; i++) {
|
|
if (xf86NameCmp (protocol, internalNames[i]) == 0)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static const char *
|
|
DefaultProtocol (void)
|
|
{
|
|
return "OSMouse";
|
|
}
|
|
|
|
static const char *
|
|
evtErrStr (int evterr)
|
|
{
|
|
switch (evterr) {
|
|
case -1: return "error in config files";
|
|
case -2: return "no mouse devices to attach";
|
|
case -3: return "unable to open device";
|
|
case -4: return "unable to open event queue";
|
|
case -999: return "unable to initialize event driver";
|
|
default: return "unknown event driver error";
|
|
}
|
|
}
|
|
|
|
static int
|
|
OsMouseProc (DeviceIntPtr pPointer, int what)
|
|
{
|
|
InputInfoPtr pInfo;
|
|
MouseDevPtr pMse;
|
|
unsigned char map[9];
|
|
dmask_t dmask;
|
|
MessageType from = X_CONFIG;
|
|
int evi;
|
|
|
|
pInfo = pPointer->public.devicePrivate;
|
|
pMse = pInfo->private;
|
|
pMse->device = pPointer;
|
|
|
|
switch (what) {
|
|
case DEVICE_INIT:
|
|
pPointer->public.on = FALSE;
|
|
|
|
dmask = D_REL | D_BUTTON;
|
|
if ((evi = ev_init()) < 0) {
|
|
FatalError ("OsMouseProc: Event driver initialization failed (%s)\n",
|
|
evtErrStr(evi));
|
|
}
|
|
pInfo->fd = ev_open (&dmask);
|
|
if (pInfo->fd < 0) {
|
|
FatalError ("OsMouseProc: DEVICE_INIT failed (%s)\n", evtErrStr(pInfo->fd));
|
|
}
|
|
|
|
pMse->buttons = xf86SetIntOption (pInfo->options, "Buttons", 0);
|
|
if (pMse->buttons == 0) {
|
|
pMse->buttons = 8;
|
|
from = X_DEFAULT;
|
|
}
|
|
xf86Msg (from, "%s: Buttons: %d\n", pInfo->name, pMse->buttons);
|
|
|
|
map[1] = 1;
|
|
map[2] = 2;
|
|
map[3] = 3;
|
|
map[4] = 6;
|
|
map[5] = 7;
|
|
map[6] = 8;
|
|
map[7] = 4;
|
|
map[8] = 5; /* Compatibile with SCO X server */
|
|
|
|
InitPointerDeviceStruct((DevicePtr)pPointer, map, 8,
|
|
miPointerGetMotionEvents, pMse->Ctrl,
|
|
miPointerGetMotionBufferSize());
|
|
|
|
/* X valuator */
|
|
xf86InitValuatorAxisStruct(pPointer, 0, 0, -1, 1, 0, 1);
|
|
xf86InitValuatorDefaults(pPointer, 0);
|
|
|
|
/* Y valuator */
|
|
xf86InitValuatorAxisStruct(pPointer, 1, 0, -1, 1, 0, 1);
|
|
xf86InitValuatorDefaults(pPointer, 1);
|
|
|
|
xf86MotionHistoryAllocate(pInfo);
|
|
|
|
ev_flush();
|
|
ev_suspend();
|
|
break;
|
|
|
|
case DEVICE_ON:
|
|
pMse->lastButtons = 0;
|
|
pMse->emulateState = 0;
|
|
pPointer->public.on = TRUE;
|
|
ev_resume();
|
|
AddEnabledDevice (pInfo->fd);
|
|
break;
|
|
|
|
case DEVICE_OFF:
|
|
case DEVICE_CLOSE:
|
|
pPointer->public.on = TRUE;
|
|
RemoveEnabledDevice (pInfo->fd);
|
|
if (what == DEVICE_CLOSE) {
|
|
ev_close();
|
|
pInfo->fd = -1;
|
|
} else {
|
|
ev_suspend();
|
|
}
|
|
break;
|
|
}
|
|
|
|
return Success;
|
|
}
|
|
|
|
static void
|
|
OsMouseReadInput (InputInfoPtr pInfo)
|
|
{
|
|
MouseDevPtr pMse;
|
|
EVENT *evp;
|
|
|
|
pMse = pInfo->private;
|
|
|
|
while ((evp = ev_read()) != (EVENT *)0) {
|
|
int buttons = EV_BUTTONS(*evp);
|
|
int dx = EV_DX(*evp), dy = -(EV_DY(*evp)), dz = 0, dw = 0;
|
|
|
|
if (EV_TAG(*evp) & T_WHEEL) {
|
|
dz = (dy & 0x08) ? (dy & 0x0f) - 16 : (dy & 0x0f);
|
|
dx = dy = 0;
|
|
pMse->PostEvent (pInfo, buttons, dx, dy, dz, dw);
|
|
/* Simulate button release */
|
|
dz = 0;
|
|
buttons &= ~(WHEEL_FWD | WHEEL_BACK);
|
|
}
|
|
|
|
pMse->PostEvent (pInfo, buttons, dx, dy, dz, dw);
|
|
ev_pop();
|
|
}
|
|
}
|
|
|
|
static Bool
|
|
OsMousePreInit(InputInfoPtr pInfo, const char *protocol, int flags)
|
|
{
|
|
MouseDevPtr pMse;
|
|
|
|
/* This is called when the protocol is "OSMouse". */
|
|
|
|
pMse = pInfo->private;
|
|
pMse->protocol = protocol;
|
|
xf86Msg(X_CONFIG, "%s: Protocol: %s\n", pInfo->name, protocol);
|
|
|
|
/* Collect the options, and process the common options. */
|
|
xf86CollectInputOptions(pInfo, NULL, NULL);
|
|
xf86ProcessCommonOptions(pInfo, pInfo->options);
|
|
|
|
/* Check if the device can be opened. */
|
|
pInfo->fd = ev_init();
|
|
if (pInfo->fd != -1) {
|
|
dmask_t dmask = (D_REL | D_BUTTON);
|
|
pInfo->fd = ev_open(&dmask);
|
|
} else {
|
|
pInfo->fd = -999;
|
|
}
|
|
|
|
if (pInfo->fd < 0) {
|
|
if (xf86GetAllowMouseOpenFail())
|
|
xf86Msg(X_WARNING, "%s: cannot open event manager (%s)\n",
|
|
pInfo->name, evtErrStr(pInfo->fd));
|
|
else {
|
|
xf86Msg(X_ERROR, "%s: cannot open event manager (%s)\n",
|
|
pInfo->name, evtErrStr(pInfo->fd));
|
|
xfree(pMse);
|
|
return FALSE;
|
|
}
|
|
}
|
|
ev_close();
|
|
pInfo->fd = -1;
|
|
|
|
/* Process common mouse options (like Emulate3Buttons, etc). */
|
|
pMse->CommonOptions(pInfo);
|
|
|
|
/* Setup the local procs. */
|
|
pInfo->device_control = OsMouseProc;
|
|
pInfo->read_input = OsMouseReadInput;
|
|
|
|
pInfo->flags |= XI86_CONFIGURED;
|
|
return TRUE;
|
|
}
|
|
|
|
OSMouseInfoPtr
|
|
xf86OSMouseInit (int flags)
|
|
{
|
|
OSMouseInfoPtr p;
|
|
|
|
p = xcalloc(sizeof(OSMouseInfoRec), 1);
|
|
if (!p)
|
|
return NULL;
|
|
|
|
p->SupportedInterfaces = SupportedInterfaces;
|
|
p->BuiltinNames = BuiltinNames;
|
|
p->DefaultProtocol = DefaultProtocol;
|
|
p->CheckProtocol = CheckProtocol;
|
|
p->PreInit = OsMousePreInit;
|
|
|
|
return p;
|
|
}
|