andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge branch 'input-hotplug'

Browse Source
This commit is contained in:
Daniel Stone 2006-11-02 03:21:37 +02:00 committed by Daniel Stone
commit 18c246a13b
238 changed files with 9735 additions and 18358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -267,3 +267,4 @@ mfb/mfbteblack.c
mfb/mfbtewhite.c
mfb/mfbtileC.c
mfb/mfbtileG.c
.*.swp

1
GL/mesa/main/Makefile.am
View File

@ -60,6 +60,7 @@ nodist_libmain_la_SOURCES = accum.c \
light.c \
lines.c \
matrix.c \
mipmap.c \
mm.c \
occlude.c \
pixel.c \

7
Makefile.am
View File

@ -26,10 +26,6 @@ if GLX
GLX_DIR=GL
endif
if XINPUT
XINPUT_DIR=Xi
endif
if DBE
DBE_DIR=dbe
endif
@ -45,7 +41,7 @@ SUBDIRS = \
os \
randr \
render \
$(XINPUT_DIR) \
Xi \
xkb \
$(DBE_DIR) \
$(MFB_DIR) \
@ -59,6 +55,7 @@ SUBDIRS = \
$(COMPOSITE_DIR) \
$(GLX_DIR) \
exa \
config \
hw
aclocaldir = $(datadir)/aclocal

146
Xi/chgdctl.c
View File

@ -66,6 +66,7 @@ SOFTWARE.
#include "extnsionst.h"
#include "extinit.h" /* LookupDeviceIntRec */
#include "exglobals.h"
#include "exevents.h"
#include "chgdctl.h"
@ -98,12 +99,17 @@ int
ProcXChangeDeviceControl(ClientPtr client)
{
unsigned len;
int i, status;
int i, status, ret = BadValue;
DeviceIntPtr dev;
xDeviceResolutionCtl *r;
xChangeDeviceControlReply rep;
AxisInfoPtr a;
CARD32 *resolution;
xDeviceAbsCalibCtl *calib;
xDeviceAbsAreaCtl *area;
xDeviceCoreCtl *c;
xDeviceEnableCtl *e;
devicePresenceNotify dpn;
REQUEST(xChangeDeviceControlReq);
REQUEST_AT_LEAST_SIZE(xChangeDeviceControlReq);
@ -111,9 +117,8 @@ ProcXChangeDeviceControl(ClientPtr client)
len = stuff->length - (sizeof(xChangeDeviceControlReq) >> 2);
dev = LookupDeviceIntRec(stuff->deviceid);
if (dev == NULL) {
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
BadDevice);
return Success;
ret = BadDevice;
goto out;
}
rep.repType = X_Reply;
@ -126,25 +131,22 @@ ProcXChangeDeviceControl(ClientPtr client)
r = (xDeviceResolutionCtl *) & stuff[1];
if ((len < (sizeof(xDeviceResolutionCtl) >> 2)) ||
(len != (sizeof(xDeviceResolutionCtl) >> 2) + r->num_valuators)) {
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl,
0, BadLength);
return Success;
ret = BadLength;
goto out;
}
if (!dev->valuator) {
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
BadMatch);
return Success;
ret = BadMatch;
goto out;
}
if ((dev->grab) && !SameClient(dev->grab, client)) {
rep.status = AlreadyGrabbed;
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
return Success;
ret = Success;
goto out;
}
resolution = (CARD32 *) (r + 1);
if (r->first_valuator + r->num_valuators > dev->valuator->numAxes) {
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
BadValue);
return Success;
ret = BadValue;
goto out;
}
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) r);
if (status == Success) {
@ -158,21 +160,119 @@ ProcXChangeDeviceControl(ClientPtr client)
}
for (i = 0; i < r->num_valuators; i++)
(a++)->resolution = *resolution++;
ret = Success;
} else if (status == DeviceBusy) {
rep.status = DeviceBusy;
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
return Success;
ret = Success;
} else {
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0,
BadMatch);
return Success;
ret = BadMatch;
}
break;
case DEVICE_ABS_CALIB:
calib = (xDeviceAbsCalibCtl *)&stuff[1];
if (calib->button_threshold < 0 || calib->button_threshold > 255) {
ret = BadValue;
goto out;
}
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) calib);
if (status == Success) {
dev->absolute->min_x = calib->min_x;
dev->absolute->max_x = calib->max_x;
dev->absolute->min_y = calib->min_y;
dev->absolute->max_y = calib->max_y;
dev->absolute->flip_x = calib->flip_x;
dev->absolute->flip_y = calib->flip_y;
dev->absolute->rotation = calib->rotation;
dev->absolute->button_threshold = calib->button_threshold;
ret = Success;
} else if (status == DeviceBusy || status == BadValue) {
rep.status = status;
ret = Success;
} else {
ret = BadMatch;
}
break;
case DEVICE_ABS_AREA:
area = (xDeviceAbsAreaCtl *)&stuff[1];
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) area);
if (status == Success) {
dev->absolute->offset_x = area->offset_x;
dev->absolute->offset_y = area->offset_y;
dev->absolute->width = area->width;
dev->absolute->height = area->height;
dev->absolute->screen = area->screen;
dev->absolute->following = area->following;
ret = Success;
} else if (status == DeviceBusy || status == BadValue) {
rep.status = status;
ret = Success;
} else {
ret = Success;
}
break;
case DEVICE_CORE:
c = (xDeviceCoreCtl *)&stuff[1];
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) c);
if (status == Success) {
dev->coreEvents = c->status;
ret = Success;
} else if (status == DeviceBusy) {
rep.status = DeviceBusy;
ret = Success;
} else {
ret = BadMatch;
}
break;
case DEVICE_ENABLE:
e = (xDeviceEnableCtl *)&stuff[1];
status = ChangeDeviceControl(client, dev, (xDeviceCtl *) e);
if (status == Success) {
if (e->enable)
EnableDevice(dev);
else
DisableDevice(dev);
ret = Success;
} else if (status == DeviceBusy) {
rep.status = DeviceBusy;
ret = Success;
} else {
ret = BadMatch;
}
break;
default:
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, BadValue);
return Success;
ret = BadValue;
}
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
out:
if (ret == Success) {
dpn.type = DevicePresenceNotify;
dpn.time = currentTime.milliseconds;
dpn.devchange = 1;
dpn.deviceid = dev->id;
dpn.control = stuff->control;
SendEventToAllWindows(dev, DevicePresenceNotifyMask,
(xEvent *) &dpn, 1);
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
}
else {
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, ret);
}
return Success;
}

102
Xi/chgkbd.c
View File

@ -64,7 +64,6 @@ SOFTWARE.
#include "XIstubs.h"
#include "globals.h"
#include "extnsionst.h"
#include "extinit.h" /* LookupDeviceIntRec */
#include "exevents.h"
#include "exglobals.h"
@ -99,107 +98,10 @@ SProcXChangeKeyboardDevice(register ClientPtr client)
int
ProcXChangeKeyboardDevice(register ClientPtr client)
{
int i;
DeviceIntPtr xkbd = inputInfo.keyboard;
DeviceIntPtr dev;
FocusClassPtr xf = xkbd->focus;
FocusClassPtr df;
KeyClassPtr k;
xChangeKeyboardDeviceReply rep;
changeDeviceNotify ev;
REQUEST(xChangeKeyboardDeviceReq);
REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
rep.repType = X_Reply;
rep.RepType = X_ChangeKeyboardDevice;
rep.length = 0;
rep.sequenceNumber = client->sequence;
dev = LookupDeviceIntRec(stuff->deviceid);
if (dev == NULL) {
rep.status = -1;
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
BadDevice);
return Success;
}
k = dev->key;
if (k == NULL) {
rep.status = -1;
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
BadMatch);
return Success;
}
if (((dev->grab) && !SameClient(dev->grab, client)) ||
((xkbd->grab) && !SameClient(xkbd->grab, client)))
rep.status = AlreadyGrabbed;
else if ((dev->sync.frozen &&
dev->sync.other && !SameClient(dev->sync.other, client)) ||
(xkbd->sync.frozen &&
xkbd->sync.other && !SameClient(xkbd->sync.other, client)))
rep.status = GrabFrozen;
else {
if (ChangeKeyboardDevice(xkbd, dev) != Success) {
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
BadDevice);
return Success;
}
if (!dev->focus)
InitFocusClassDeviceStruct(dev);
if (!dev->kbdfeed)
InitKbdFeedbackClassDeviceStruct(dev, (BellProcPtr) NoopDDA,
(KbdCtrlProcPtr) NoopDDA);
df = dev->focus;
df->win = xf->win;
df->revert = xf->revert;
df->time = xf->time;
df->traceGood = xf->traceGood;
if (df->traceSize != xf->traceSize) {
Must_have_memory = TRUE; /* XXX */
df->trace = (WindowPtr *) xrealloc(df->trace,
xf->traceSize *
sizeof(WindowPtr));
Must_have_memory = FALSE; /* XXX */
}
df->traceSize = xf->traceSize;
for (i = 0; i < df->traceSize; i++)
df->trace[i] = xf->trace[i];
RegisterOtherDevice(xkbd);
RegisterKeyboardDevice(dev);
ev.type = ChangeDeviceNotify;
ev.deviceid = stuff->deviceid;
ev.time = currentTime.milliseconds;
ev.request = NewKeyboard;
SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
SendMappingNotify(MappingKeyboard, k->curKeySyms.minKeyCode,
k->curKeySyms.maxKeyCode - k->curKeySyms.minKeyCode +
1, client);
rep.status = 0;
}
WriteReplyToClient(client, sizeof(xChangeKeyboardDeviceReply), &rep);
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
BadDevice);
return Success;
}
/***********************************************************************
*
* This procedure writes the reply for the XChangeKeyboardDevice
* function, if the client and server have a different byte ordering.
*
*/
void
SRepXChangeKeyboardDevice(ClientPtr client, int size,
xChangeKeyboardDeviceReply * rep)
{
register char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
WriteToClient(client, size, (char *)rep);
}

5
Xi/chgkbd.h
View File

@ -36,9 +36,4 @@ int SProcXChangeKeyboardDevice(ClientPtr /* client */
int ProcXChangeKeyboardDevice(ClientPtr /* client */
);
void SRepXChangeKeyboardDevice(ClientPtr /* client */ ,
int /* size */ ,
xChangeKeyboardDeviceReply * /* rep */
);
#endif /* CHGKBD_H */

132
Xi/chgptr.c
View File

@ -101,138 +101,10 @@ SProcXChangePointerDevice(register ClientPtr client)
int
ProcXChangePointerDevice(register ClientPtr client)
{
DeviceIntPtr xptr = inputInfo.pointer;
DeviceIntPtr dev;
ValuatorClassPtr v;
xChangePointerDeviceReply rep;
changeDeviceNotify ev;
REQUEST(xChangePointerDeviceReq);
REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
rep.repType = X_Reply;
rep.RepType = X_ChangePointerDevice;
rep.length = 0;
rep.sequenceNumber = client->sequence;
dev = LookupDeviceIntRec(stuff->deviceid);
if (dev == NULL) {
rep.status = -1;
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
BadDevice);
return Success;
}
v = dev->valuator;
if (v == NULL || v->numAxes < 2 ||
stuff->xaxis >= v->numAxes || stuff->yaxis >= v->numAxes) {
rep.status = -1;
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0, BadMatch);
return Success;
}
if (((dev->grab) && !SameClient(dev->grab, client)) ||
((xptr->grab) && !SameClient(xptr->grab, client)))
rep.status = AlreadyGrabbed;
else if ((dev->sync.frozen &&
dev->sync.other && !SameClient(dev->sync.other, client)) ||
(xptr->sync.frozen &&
xptr->sync.other && !SameClient(xptr->sync.other, client)))
rep.status = GrabFrozen;
else {
if (ChangePointerDevice(xptr, dev, stuff->xaxis, stuff->yaxis) !=
Success) {
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
BadDevice);
return Success;
}
if (dev->focus)
DeleteFocusClassDeviceStruct(dev);
if (!dev->button)
InitButtonClassDeviceStruct(dev, 0, NULL);
if (!dev->ptrfeed)
InitPtrFeedbackClassDeviceStruct(dev, (PtrCtrlProcPtr) NoopDDA);
RegisterOtherDevice(xptr);
RegisterPointerDevice(dev);
ev.type = ChangeDeviceNotify;
ev.deviceid = stuff->deviceid;
ev.time = currentTime.milliseconds;
ev.request = NewPointer;
SendEventToAllWindows(dev, ChangeDeviceNotifyMask, (xEvent *) & ev, 1);
SendMappingNotify(MappingPointer, 0, 0, client);
rep.status = 0;
}
WriteReplyToClient(client, sizeof(xChangePointerDeviceReply), &rep);
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
BadDevice);
return Success;
}
void
DeleteFocusClassDeviceStruct(DeviceIntPtr dev)
{
xfree(dev->focus->trace);
xfree(dev->focus);
dev->focus = NULL;
}
/***********************************************************************
*
* Send an event to interested clients in all windows on all screens.
*
*/
void
SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
{
int i;
WindowPtr pWin, p1;
for (i = 0; i < screenInfo.numScreens; i++) {
pWin = WindowTable[i];
(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
p1 = pWin->firstChild;
FindInterestedChildren(dev, p1, mask, ev, count);
}
}
/***********************************************************************
*
* Walk through the window tree, finding all clients that want to know
* about the ChangeDeviceNotify Event.
*
*/
void
FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
xEvent * ev, int count)
{
WindowPtr p2;
while (p1) {
p2 = p1->firstChild;
(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
FindInterestedChildren(dev, p2, mask, ev, count);
p1 = p1->nextSib;
}
}
/***********************************************************************
*
* This procedure writes the reply for the XChangePointerDevice
* function, if the client and server have a different byte ordering.
*
*/
void
SRepXChangePointerDevice(ClientPtr client, int size,
xChangePointerDeviceReply * rep)
{
register char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
WriteToClient(client, size, (char *)rep);
}

5
Xi/chgptr.h
View File

@ -53,9 +53,4 @@ void FindInterestedChildren( /* FIXME: could be static? */
int /* count */
);
void SRepXChangePointerDevice(ClientPtr /* client */ ,
int /* size */ ,
xChangePointerDeviceReply * /* rep */
);
#endif /* CHGPTR_H */

53
Xi/exevents.c
View File

@ -71,8 +71,7 @@ SOFTWARE.
#include "exglobals.h"
#include "dixevents.h" /* DeliverFocusedEvent */
#include "dixgrabs.h" /* CreateGrab() */
#include "chgptr.h"
#include "scrnintstr.h"
#define WID(w) ((w) ? ((w)->drawable.id) : 0)
#define AllModifiersMask ( \
@ -302,7 +301,12 @@ _X_EXPORT void
InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, int minval, int maxval,
int resolution, int min_res, int max_res)
{
register AxisInfoPtr ax = dev->valuator->axes + axnum;
register AxisInfoPtr ax;
if (!dev || !dev->valuator)
return;
ax = dev->valuator->axes + axnum;
ax->min_value = minval;
ax->max_value = maxval;
@ -898,7 +902,7 @@ SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
return MappingBusy;
} else {
for (i = 0; i < inputMapLen; i++) {
if (inputMap[i] && !LegalModifier(inputMap[i], (DevicePtr) dev)) {
if (inputMap[i] && !LegalModifier(inputMap[i], dev)) {
return MappingFailed;
}
}
@ -1209,3 +1213,44 @@ ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
else
return FALSE;
}
/***********************************************************************
*
* Walk through the window tree, finding all clients that want to know
* about the Event.
*
*/
void
FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
xEvent * ev, int count)
{
WindowPtr p2;
while (p1) {
p2 = p1->firstChild;
(void)DeliverEventsToWindow(p1, ev, count, mask, NullGrab, dev->id);
FindInterestedChildren(dev, p2, mask, ev, count);
p1 = p1->nextSib;
}
}
/***********************************************************************
*
* Send an event to interested clients in all windows on all screens.
*
*/
void
SendEventToAllWindows(DeviceIntPtr dev, Mask mask, xEvent * ev, int count)
{
int i;
WindowPtr pWin, p1;
for (i = 0; i < screenInfo.numScreens; i++) {
pWin = WindowTable[i];
(void)DeliverEventsToWindow(pWin, ev, count, mask, NullGrab, dev->id);
p1 = pWin->firstChild;
FindInterestedChildren(dev, p1, mask, ev, count);
}
}

7
Xi/exglobals.h
View File

@ -51,6 +51,7 @@ extern Mask DeviceMappingNotifyMask;
extern Mask DeviceOwnerGrabButtonMask;
extern Mask DeviceButtonGrabMask;
extern Mask DeviceButtonMotionMask;
extern Mask DevicePresenceNotifyMask;
extern Mask PropagateMask[];
extern int DeviceValuator;
@ -68,12 +69,8 @@ extern int DeviceKeyStateNotify;
extern int DeviceButtonStateNotify;
extern int DeviceMappingNotify;
extern int ChangeDeviceNotify;
extern int DevicePresenceNotify;
extern int RT_INPUTCLIENT;
#if 0
/* FIXME: in dix */
extern InputInfo inputInfo;
#endif
#endif /* EXGLOBALS_H */

46
Xi/extinit.c
View File

@ -166,6 +166,7 @@ Mask DeviceMappingNotifyMask;
Mask DeviceOwnerGrabButtonMask;
Mask DeviceButtonGrabMask;
Mask DeviceButtonMotionMask;
Mask DevicePresenceNotifyMask;
int DeviceValuator;
int DeviceKeyPress;
@ -182,6 +183,7 @@ int DeviceKeyStateNotify;
int DeviceButtonStateNotify;
int DeviceMappingNotify;
int ChangeDeviceNotify;
int DevicePresenceNotify;
int RT_INPUTCLIENT;
@ -202,8 +204,8 @@ Mask PropagateMask[MAX_DEVICES];
*/
static XExtensionVersion thisversion = { XI_Present,
XI_Add_XChangeDeviceControl_Major,
XI_Add_XChangeDeviceControl_Minor
XI_Add_DevicePresenceNotify_Major,
XI_Add_DevicePresenceNotify_Minor
};
/**********************************************************************
@ -463,12 +465,6 @@ SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
else if (rep->RepType == X_GetDeviceMotionEvents)
SRepXGetDeviceMotionEvents(client, len,
(xGetDeviceMotionEventsReply *) rep);
else if (rep->RepType == X_ChangeKeyboardDevice)
SRepXChangeKeyboardDevice(client, len,
(xChangeKeyboardDeviceReply *) rep);
else if (rep->RepType == X_ChangePointerDevice)
SRepXChangePointerDevice(client, len,
(xChangePointerDeviceReply *) rep);
else if (rep->RepType == X_GrabDevice)
SRepXGrabDevice(client, len, (xGrabDeviceReply *) rep);
else if (rep->RepType == X_GetDeviceFocus)
@ -648,6 +644,17 @@ SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
swapl(&to->time, n);
}
void
SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to)
{
register char n;
*to = *from;
swaps(&to->sequenceNumber,n);
swapl(&to->time, n);
swaps(&to->control, n);
}
/************************************************************************
*
* This function sets up extension event types and masks.
@ -674,6 +681,7 @@ FixExtensionEvents(ExtensionEntry * extEntry)
ChangeDeviceNotify = DeviceMappingNotify + 1;
DeviceKeyStateNotify = ChangeDeviceNotify + 1;
DeviceButtonStateNotify = DeviceKeyStateNotify + 1;
DevicePresenceNotify = DeviceButtonStateNotify + 1;
event_base[KeyClass] = DeviceKeyPress;
event_base[ButtonClass] = DeviceButtonPress;
@ -746,6 +754,9 @@ FixExtensionEvents(ExtensionEntry * extEntry)
DeviceOwnerGrabButtonMask = GetNextExtEventMask();
SetEventInfo(DeviceOwnerGrabButtonMask, _deviceOwnerGrabButton);
DevicePresenceNotifyMask = GetNextExtEventMask();
SetEventInfo(DevicePresenceNotifyMask, _devicePresence);
SetEventInfo(0, _noExtensionEvent);
}
@ -786,6 +797,7 @@ RestoreExtensionEvents(void)
ChangeDeviceNotify = 12;
DeviceKeyStateNotify = 13;
DeviceButtonStateNotify = 13;
DevicePresenceNotify = 14;
BadDevice = 0;
BadEvent = 1;
@ -823,6 +835,7 @@ IResetProc(ExtensionEntry * unused)
EventSwapVector[DeviceButtonStateNotify] = NotImplemented;
EventSwapVector[DeviceMappingNotify] = NotImplemented;
EventSwapVector[ChangeDeviceNotify] = NotImplemented;
EventSwapVector[DevicePresenceNotify] = NotImplemented;
RestoreExtensionEvents();
}
@ -857,9 +870,7 @@ MakeDeviceTypeAtoms(void)
}
/**************************************************************************
*
* Return a DeviceIntPtr corresponding to a specified device id.
* This will not return the pointer or keyboard, or devices that are not on.
*
*/
@ -869,13 +880,16 @@ LookupDeviceIntRec(CARD8 id)
DeviceIntPtr dev;
for (dev = inputInfo.devices; dev; dev = dev->next) {
if (dev->id == id) {
if (id == inputInfo.pointer->id || id == inputInfo.keyboard->id)
return (NULL);
return (dev);
}
if (dev->id == id)
return dev;
}
return (NULL);
for (dev = inputInfo.off_devices; dev; dev = dev->next) {
if (dev->id == id)
return dev;
}
return NULL;
}
/**************************************************************************

128
Xi/getdctl.c
View File

@ -124,6 +124,30 @@ ProcXGetDeviceControl(ClientPtr client)
total_length = sizeof(xDeviceResolutionState) +
(3 * sizeof(int) * dev->valuator->numAxes);
break;
case DEVICE_ABS_CALIB:
if (!dev->absolute) {
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
BadMatch);
return Success;
}
total_length = sizeof(xDeviceAbsCalibCtl);
break;
case DEVICE_ABS_AREA:
if (!dev->absolute) {
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
BadMatch);
return Success;
}
total_length = sizeof(xDeviceAbsAreaCtl);
break;
case DEVICE_CORE:
total_length = sizeof(xDeviceCoreCtl);
break;
case DEVICE_ENABLE:
total_length = sizeof(xDeviceEnableCtl);
break;
default:
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
return Success;
@ -140,6 +164,18 @@ ProcXGetDeviceControl(ClientPtr client)
case DEVICE_RESOLUTION:
CopySwapDeviceResolution(client, dev->valuator, buf, total_length);
break;
case DEVICE_ABS_CALIB:
CopySwapDeviceAbsCalib(client, dev->absolute, buf);
break;
case DEVICE_ABS_AREA:
CopySwapDeviceAbsArea(client, dev->absolute, buf);
break;
case DEVICE_CORE:
CopySwapDeviceCore(client, dev, buf);
break;
case DEVICE_ENABLE:
CopySwapDeviceEnable(client, dev, buf);
break;
default:
break;
}
@ -189,6 +225,98 @@ CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
}
}
void CopySwapDeviceAbsCalib (ClientPtr client, AbsoluteClassPtr dts,
char *buf)
{
register char n;
xDeviceAbsCalibState *calib = (xDeviceAbsCalibState *) buf;
calib->control = DEVICE_ABS_CALIB;
calib->length = sizeof(calib);
calib->min_x = dts->min_x;
calib->max_x = dts->max_x;
calib->min_y = dts->min_y;
calib->max_y = dts->max_y;
calib->flip_x = dts->flip_x;
calib->flip_y = dts->flip_y;
calib->rotation = dts->rotation;
calib->button_threshold = dts->button_threshold;
if (client->swapped) {
swaps(&calib->control, n);
swaps(&calib->length, n);
swapl(&calib->min_x, n);
swapl(&calib->max_x, n);
swapl(&calib->min_y, n);
swapl(&calib->max_y, n);
swapl(&calib->flip_x, n);
swapl(&calib->flip_y, n);
swapl(&calib->rotation, n);
swapl(&calib->button_threshold, n);
}
}
void CopySwapDeviceAbsArea (ClientPtr client, AbsoluteClassPtr dts,
char *buf)
{
register char n;
xDeviceAbsAreaState *area = (xDeviceAbsAreaState *) buf;
area->control = DEVICE_ABS_AREA;
area->length = sizeof(area);
area->offset_x = dts->offset_x;
area->offset_y = dts->offset_y;
area->width = dts->width;
area->height = dts->height;
area->screen = dts->screen;
area->following = dts->following;
if (client->swapped) {
swaps(&area->control, n);
swaps(&area->length, n);
swapl(&area->offset_x, n);
swapl(&area->offset_y, n);
swapl(&area->width, n);
swapl(&area->height, n);
swapl(&area->screen, n);
swapl(&area->following, n);
}
}
void CopySwapDeviceCore (ClientPtr client, DeviceIntPtr dev, char *buf)
{
register char n;
xDeviceCoreState *c = (xDeviceCoreState *) buf;
c->control = DEVICE_CORE;
c->length = sizeof(c);
c->status = dev->coreEvents;
c->iscore = (dev == inputInfo.keyboard || dev == inputInfo.pointer);
if (client->swapped) {
swaps(&c->control, n);
swaps(&c->length, n);
swaps(&c->status, n);
}
}
void CopySwapDeviceEnable (ClientPtr client, DeviceIntPtr dev, char *buf)
{
register char n;
xDeviceEnableState *e = (xDeviceEnableState *) buf;
e->control = DEVICE_ENABLE;
e->length = sizeof(e);
e->enable = dev->enabled;
if (client->swapped) {
swaps(&e->control, n);
swaps(&e->length, n);
swaps(&e->enable, n);
}
}
/***********************************************************************
*
* This procedure writes the reply for the xGetDeviceControl function,

18
Xi/getdctl.h
View File

@ -42,6 +42,24 @@ void CopySwapDeviceResolution(ClientPtr /* client */ ,
int /* length */
);
void CopySwapDeviceAbsCalib (ClientPtr client,
AbsoluteClassPtr dts,
char *buf);
void CopySwapDeviceAbsArea (ClientPtr client,
AbsoluteClassPtr dts,
char *buf);
void CopySwapDeviceCore(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
char * /* buf */
);
void CopySwapDeviceEnable(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
char * /* buf */
);
void SRepXGetDeviceControl(ClientPtr /* client */ ,
int /* size */ ,
xGetDeviceControlReply * /* rep */

15
Xi/listdev.c
View File

@ -96,7 +96,7 @@ int
ProcXListInputDevices(register ClientPtr client)
{
xListInputDevicesReply rep;
int numdevs;
int numdevs = 0;
int namesize = 1; /* need 1 extra byte for strcpy */
int size = 0;
int total_length;
@ -115,12 +115,15 @@ ProcXListInputDevices(register ClientPtr client)
rep.sequenceNumber = client->sequence;
AddOtherInputDevices();
numdevs = inputInfo.numDevices;
for (d = inputInfo.devices; d; d = d->next)
for (d = inputInfo.devices; d; d = d->next) {
SizeDeviceInfo(d, &namesize, &size);
for (d = inputInfo.off_devices; d; d = d->next)
numdevs++;
}
for (d = inputInfo.off_devices; d; d = d->next) {
SizeDeviceInfo(d, &namesize, &size);
numdevs++;
}
total_length = numdevs * sizeof(xDeviceInfo) + size + namesize;
devbuf = (char *)xalloc(total_length);
@ -241,6 +244,10 @@ CopySwapDevice(register ClientPtr client, DeviceIntPtr d, int num_classes,
dev->use = IsXKeyboard;
else if (d == inputInfo.pointer)
dev->use = IsXPointer;
else if (d->key && d->kbdfeed)
dev->use = IsXExtensionKeyboard;
else if (d->valuator && d->button)
dev->use = IsXExtensionPointer;
else
dev->use = IsXExtensionDevice;
if (client->swapped) {

54
Xi/selectev.c
View File

@ -74,6 +74,53 @@ SOFTWARE.
extern Mask ExtExclusiveMasks[];
extern Mask ExtValidMasks[];
static int
HandleDevicePresenceMask(ClientPtr client, WindowPtr win,
XEventClass *cls, CARD16 *count)
{
int i, j;
Mask mask;
/* We use the device ID 256 to select events that aren't bound to
* any device. For now we only handle the device presence event,
* but this could be extended to other events that aren't bound to
* a device.
*
* In order not to break in CreateMaskFromList() we remove the
* entries with device ID 256 from the XEventClass array.
*/
mask = 0;
for (i = 0, j = 0; i < *count; i++) {
if (cls[i] >> 8 != 256) {
cls[j] = cls[i];
j++;
continue;
}
switch (cls[i] & 0xff) {
case _devicePresence:
mask |= DevicePresenceNotifyMask;
break;
}
}
*count = j;
if (mask == 0)
return Success;
/* We always only use mksidx = 0 for events not bound to
* devices */
if (AddExtensionClient (win, client, mask, 0) != Success)
return BadAlloc;
RecalculateDeviceDeliverableEvents(win);
return Success;
}
/***********************************************************************
*
* Handle requests from clients with a different byte order.
@ -131,6 +178,13 @@ ProcXSelectExtensionEvent(register ClientPtr client)
return Success;
}
if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
&stuff->count) != Success) {
SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
BadAlloc);
return Success;
}
if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
stuff->count, tmp, NULL,
X_SelectExtensionEvent)) != Success)

99
Xi/stubs.c
View File

@ -66,86 +66,6 @@ SOFTWARE.
#include <X11/extensions/XIproto.h>
#include "XIstubs.h"
/***********************************************************************
*
* Caller: ProcXChangeKeyboardDevice
*
* This procedure does the implementation-dependent portion of the work
* needed to change the keyboard device.
*
* The X keyboard device has a FocusRec. If the device that has been
* made into the new X keyboard did not have a FocusRec,
* ProcXChangeKeyboardDevice will allocate one for it.
*
* If you do not want clients to be able to focus the old X keyboard
* device, call DeleteFocusClassDeviceStruct to free the FocusRec.
*
* If you support input devices with keys that you do not want to be
* used as the X keyboard, you need to check for them here and return
* a BadDevice error.
*
* The default implementation is to do nothing (assume you do want
* clients to be able to focus the old X keyboard). The commented-out
* sample code shows what you might do if you don't want the default.
*
*/
int
ChangeKeyboardDevice(DeviceIntPtr old_dev, DeviceIntPtr new_dev)
{
/***********************************************************************
DeleteFocusClassDeviceStruct(old_dev); * defined in xchgptr.c *
**********************************************************************/
return BadMatch;
}
/***********************************************************************
*
* Caller: ProcXChangePointerDevice
*
* This procedure does the implementation-dependent portion of the work
* needed to change the pointer device.
*
* The X pointer device does not have a FocusRec. If the device that
* has been made into the new X pointer had a FocusRec,
* ProcXChangePointerDevice will free it.
*
* If you want clients to be able to focus the old pointer device that
* has now become accessible through the input extension, you need to
* add a FocusRec to it here.
*
* The XChangePointerDevice protocol request also allows the client
* to choose which axes of the new pointer device are used to move
* the X cursor in the X- and Y- directions. If the axes are different
* than the default ones, you need to keep track of that here.
*
* If you support input devices with valuators that you do not want to be
* used as the X pointer, you need to check for them here and return a
* BadDevice error.
*
* The default implementation is to do nothing (assume you don't want
* clients to be able to focus the old X pointer). The commented-out
* sample code shows what you might do if you don't want the default.
*
*/
int
ChangePointerDevice(DeviceIntPtr old_dev,
DeviceIntPtr new_dev, unsigned char x, unsigned char y)
{
/***********************************************************************
InitFocusClassDeviceStruct(old_dev); * allow focusing old ptr*
x_axis = x; * keep track of new x-axis*
y_axis = y; * keep track of new y-axis*
if (x_axis != 0 || y_axis != 1)
axes_changed = TRUE; * remember axes have changed*
else
axes_changed = FALSE;
*************************************************************************/
return BadMatch;
}
/***********************************************************************
*
* Caller: ProcXCloseDevice
@ -287,7 +207,26 @@ ChangeDeviceControl(register ClientPtr client, DeviceIntPtr dev,
switch (control->control) {
case DEVICE_RESOLUTION:
return (BadMatch);
case DEVICE_ABS_CALIB:
case DEVICE_ABS_AREA:
return (BadMatch);
case DEVICE_CORE:
return (BadMatch);
default:
return (BadMatch);
}
}
/****************************************************************************
*
* Caller: configAddDevice (and others)
*
* Add a new device with the specified options.
*
*/
int
NewInputDeviceRequest(InputOption *options)
{
return BadValue;
}

10
config/Makefile.am Normal file
View File

@ -0,0 +1,10 @@
AM_CFLAGS = @DIX_CFLAGS@
dbusconfigdir = $(sysconfdir)/dbus-1/system.d
dbusconfig_DATA = xorg-server.conf
lib_LIBRARIES = libconfig.a
libconfig_a_SOURCES = config.c
EXTRA_DIST = xorg-server.conf

349
config/config.c Normal file
View File

@ -0,0 +1,349 @@
/*
* Copyright © 2006 Daniel Stone
*
* 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 of the copyright holders and/or authors
* not be used in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission. The copyright holders
* and/or authors make no representations about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*
* THE COPYRIGHT HOLDERS AND/OR AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD
* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND/OR AUTHORS 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.
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#ifdef HAVE_DBUS
#define DBUS_API_SUBJECT_TO_CHANGE
#include <dbus/dbus.h>
#include <string.h>
#include <X11/X.h>
#include "opaque.h" /* for 'display': there has to be a better way */
/* the above comment lies. there is no better way. */
#include "input.h"
#include "inputstr.h"
#include "config.h"
#include "os.h"
#define MATCH_RULE "type='method_call',interface='org.x.config.input'"
#define MALFORMED_MSG "[config] malformed message, dropping"
#define MALFORMED_MESSAGE() { DebugF(MALFORMED_MSG "\n"); \
ret = BadValue; \
goto unwind; }
#define MALFORMED_MESSAGE_ERROR() { DebugF(MALFORMED_MSG ": %s, %s", \
error->name, error->message); \
ret = BadValue; \
goto unwind; }
static DBusConnection *configConnection = NULL;
static int configfd = -1;
static char busobject[32] = { 0 };
static char busname[64] = { 0 };
void
configDispatch()
{
if (!configConnection)
return;
dbus_connection_read_write_dispatch(configConnection, 0);
}
static int
configAddDevice(DBusMessage *message, DBusMessageIter *iter, DBusError *error)
{
DBusMessageIter subiter;
InputOption *tmpo = NULL, *options = NULL;
char *tmp = NULL;
int ret = BadMatch;
DebugF("[config] adding device\n");
/* signature should be [ss][ss]... */
options = (InputOption *) xcalloc(sizeof(InputOption), 1);
if (!options) {
ErrorF("[config] couldn't allocate option\n");
return BadAlloc;
}
options->key = xstrdup("_source");
options->value = xstrdup("client/dbus");
while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_ARRAY) {
tmpo = (InputOption *) xcalloc(sizeof(InputOption), 1);
if (!tmpo) {
ErrorF("[config] couldn't allocate option\n");
ret = BadAlloc;
goto unwind;
}
dbus_message_iter_recurse(iter, &subiter);
if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
MALFORMED_MESSAGE();
dbus_message_iter_get_basic(&subiter, &tmp);
if (!tmp)
MALFORMED_MESSAGE();
if (tmp[0] == '_') {
ErrorF("[config] attempted subterfuge: option name %s given\n",
tmp);
MALFORMED_MESSAGE();
}
tmpo->key = xstrdup(tmp);
if (!tmpo->key) {
ErrorF("[config] couldn't duplicate key!\n");
ret = BadAlloc;
goto unwind;
}
if (!dbus_message_iter_has_next(&subiter))
MALFORMED_MESSAGE();
dbus_message_iter_next(&subiter);
if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
MALFORMED_MESSAGE();
dbus_message_iter_get_basic(&subiter, &tmp);
if (!tmp)
MALFORMED_MESSAGE();
tmpo->value = xstrdup(tmp);
if (!tmpo->value) {
ErrorF("[config] couldn't duplicate option!\n");
ret = BadAlloc;
goto unwind;
}
tmpo->next = options;
options = tmpo;
dbus_message_iter_next(iter);
}
ret = NewInputDeviceRequest(options);
if (ret != Success)
DebugF("[config] NewInputDeviceRequest failed\n");
return ret;
unwind:
if (tmpo->key)
xfree(tmpo->key);
if (tmpo->value)
xfree(tmpo->value);
if (tmpo)
xfree(tmpo);
while (options) {
tmpo = options;
options = options->next;
if (tmpo->key)
xfree(tmpo->key);
if (tmpo->value)
xfree(tmpo->value);
xfree(tmpo);
}
return ret;
}
static int
configRemoveDevice(DBusMessage *message, DBusMessageIter *iter,
DBusError *error)
{
int deviceid = -1;
int ret = BadMatch;
DeviceIntPtr pDev = NULL;
if (!dbus_message_get_args(message, error, DBUS_TYPE_INT32,
&deviceid, DBUS_TYPE_INVALID)) {
MALFORMED_MESSAGE_ERROR();
}
if (deviceid < 0 || !(pDev = LookupDeviceIntRec(deviceid))) {
DebugF("[config] bogus device id %d given\n", deviceid);
ret = BadMatch;
goto unwind;
}
DebugF("[config] removing device %s (id %d)\n", pDev->name, deviceid);
/* Call PIE here so we don't try to dereference a device that's
* already been removed. */
OsBlockSignals();
ProcessInputEvents();
RemoveDevice(pDev);
OsReleaseSignals();
return Success;
unwind:
return ret;
}
static DBusHandlerResult
configMessage(DBusConnection *connection, DBusMessage *message, void *closure)
{
DBusMessageIter iter;
DBusError error;
DBusMessage *reply;
DBusConnection *bus = closure;
int ret = BadDrawable; /* nonsensical value */
dbus_error_init(&error);
if (strcmp(dbus_message_get_interface(message),
"org.x.config.input") == 0) {
if (!dbus_message_iter_init(message, &iter)) {
ErrorF("[config] failed to init iterator\n");
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY; /* ?? */
}
if (strcmp(dbus_message_get_member(message), "add") == 0)
ret = configAddDevice(message, &iter, &error);
else if (strcmp(dbus_message_get_member(message), "remove") == 0)
ret = configRemoveDevice(message, &iter, &error);
}
if (ret != BadDrawable && ret != BadAlloc) {
reply = dbus_message_new_method_return(message);
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &ret)) {
ErrorF("[config] couldn't append to iterator\n");
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_HANDLED;
}
if (!dbus_connection_send(bus, reply, NULL))
ErrorF("[config] failed to send reply\n");
dbus_connection_flush(bus);
dbus_message_unref(reply);
}
dbus_error_free(&error);
if (ret == BadAlloc)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
else if (ret == BadDrawable)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
else
return DBUS_HANDLER_RESULT_HANDLED;
}
void
configInitialise()
{
DBusConnection *bus = NULL;
DBusError error;
DBusObjectPathVTable vtable = { .message_function = configMessage };
configConnection = NULL;
dbus_error_init(&error);
bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (!bus || dbus_error_is_set(&error)) {
dbus_error_free(&error);
FatalError("[dbus] some kind of error occurred: %s (%s)\n", error.name,
error.message);
return;
}
if (!dbus_connection_get_unix_fd(bus, &configfd)) {
dbus_connection_unref(bus);
configfd = -1;
FatalError("[dbus] couldn't get fd for bus\n");
return;
}
snprintf(busname, sizeof(busname), "org.x.config.display%d", atoi(display));
if (!dbus_bus_request_name(bus, busname, 0, &error) ||
dbus_error_is_set(&error)) {
dbus_error_free(&error);
dbus_connection_unref(bus);
configfd = -1;
FatalError("[dbus] couldn't take over org.x.config: %s (%s)\n",
error.name, error.message);
return;
}
/* blocks until we get a reply. */
dbus_bus_add_match(bus, MATCH_RULE, &error);
if (dbus_error_is_set(&error)) {
dbus_error_free(&error);
dbus_bus_release_name(bus, busname, &error);
dbus_connection_unref(bus);
configfd = -1;
FatalError("[dbus] couldn't match X.Org rule: %s (%s)\n", error.name,
error.message);
return;
}
snprintf(busobject, sizeof(busobject), "/org/x/config/%d", atoi(display));
if (!dbus_connection_register_object_path(bus, busobject, &vtable, bus)) {
configfd = -1;
dbus_bus_release_name(bus, busname, &error);
dbus_bus_remove_match(bus, MATCH_RULE, &error);
dbus_connection_unref(bus);
FatalError("[dbus] couldn't register object path\n");
return;
}
DebugF("[dbus] registered object path %s\n", busobject);
dbus_error_free(&error);
configConnection = bus;
AddGeneralSocket(configfd);
}
void
configFini()
{
DBusError error;
if (configConnection) {
dbus_error_init(&error);
dbus_connection_unregister_object_path(configConnection, busobject);
dbus_bus_remove_match(configConnection, MATCH_RULE, &error);
dbus_bus_release_name(configConnection, busname, &error);
dbus_connection_unref(configConnection);
RemoveGeneralSocket(configfd);
configConnection = NULL;
configfd = -1;
dbus_error_free(&error);
}
}
#else /* !HAVE_DBUS */
void
configDispatch()
{
}
void
configInitialise()
{
}
void
configFini()
{
}
#endif /* HAVE_DBUS */

35
config/dbus-api Normal file
View File

@ -0,0 +1,35 @@
D-BUS Configuration API v0.1
----------------------------
The X server will register the bus name org.x.config.displayN, and the
object /org/x/config/N, where N is the display number.
Currently only hotplugging of input devices is supported.
org.x.config.input:
org.x.config.input.add:
Takes an argument of key/value option pairs in arrays, e.g.:
[ss][ss][ss][ss]
is the signature for four options. These options will be passed
to the input driver as with any others.
Option names beginning with _ are not allowed; they are reserved
for internal use.
Returns one int32, which is an X Status, as defined in X.h. If
everything is successful, Success will be returned. BadMatch will
be returned if the options given do not match any device. BadValue
is returned for a malformed message.
Notably, BadAlloc is never returned: the server internally signals
to D-BUS that the attempt failed for lack of memory.
The return does not notify the client of which devices were created
or modified as a result of this request: clients are encouraged to
listen for the XInput DevicePresenceNotify event to monitor changes
in the device list.
org.x.config.input.remove:
Takes one int32 argument, which is the device ID to remove, i.e.:
i
is the signature.
Same return values as org.x.config.input.add.

13
config/xorg-server.conf Normal file
View File

@ -0,0 +1,13 @@
<!DOCTYPE busconfig PUBLIC
"-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig>
<policy context="default">
<allow own="org.x.config.display0"/>
<allow send_destination="org.x.config.display0"/>
<allow send_interface="org.x.config.display0"/>
<allow own="org.x.config.display1"/>
<allow send_destination="org.x.config.display1"/>
<allow send_interface="org.x.config.display1"/>
</policy>
</busconfig>

297
configure.ac
View File

@ -49,7 +49,8 @@ dnl xwin-config.h covers the XWin DDX.
AC_CONFIG_HEADERS(include/xwin-config.h)
dnl kdrive-config.h covers the kdrive DDX
AC_CONFIG_HEADERS(include/kdrive-config.h)
dnl libdrm now needs 64-bit file offsets
AC_CONFIG_HEADERS(include/libdrm-config.h)
AC_PROG_CC
AM_PROG_AS
@ -62,6 +63,7 @@ AC_PROG_MAKE_SET
PKG_PROG_PKG_CONFIG
AC_PROG_LEX
AC_PROG_YACC
AC_SYS_LARGEFILE
XORG_PROG_RAWCPP
AC_HEADER_DIRENT
@ -394,6 +396,12 @@ AC_ARG_ENABLE(install-libxf86config,
[Install libxf86config (default: disabled)]),
[INSTALL_LIBXF86CONFIG=$enableval],
[INSTALL_LIBXF86CONFIG=no])
AC_ARG_ENABLE(builtin-fonts, AS_HELP_STRING([--enable-builtin-fonts], [Use only built-in fonts (default: use external)]),
[BUILTIN_FONTS=$enableval],
[BUILTIN_FONTS=no])
AC_ARG_ENABLE(null-root-cursor, AS_HELP_STRING([--enable-null-root-cursor], [Use an empty root cursor (default: use core cursor)]),
[NULL_ROOT_CURSOR=$enableval],
[NULL_ROOT_CURSOR=no])
dnl Extensions.
AC_ARG_ENABLE(composite, AS_HELP_STRING([--disable-composite], [Build Composite extension (default: enabled)]), [COMPOSITE=$enableval], [COMPOSITE=yes])
@ -403,7 +411,7 @@ AC_ARG_ENABLE(xtrap, AS_HELP_STRING([--disable-xtrap], [Build XTrap ext
AC_ARG_ENABLE(record, AS_HELP_STRING([--disable-record], [Build Record extension (default: enabled)]), [RECORD=$enableval], [RECORD=yes])
AC_ARG_ENABLE(xv, AS_HELP_STRING([--disable-xv], [Build Xv extension (default: enabled)]), [XV=$enableval], [XV=yes])
AC_ARG_ENABLE(xvmc, AS_HELP_STRING([--disable-xvmc], [Build XvMC extension (default: enabled)]), [XVMC=$enableval], [XVMC=yes])
AC_ARG_ENABLE(dga, AS_HELP_STRING([--disable-dga], [Build DGA extension (default: enabled)]), [DGA=$enableval], [DGA=yes])
AC_ARG_ENABLE(dga, AS_HELP_STRING([--disable-dga], [Build DGA extension (default: auto)]), [DGA=$enableval], [DGA=auto])
AC_ARG_ENABLE(screensaver, AS_HELP_STRING([--disable-screensaver], [Build ScreenSaver extension (default: enabled)]), [SCREENSAVER=$enableval], [SCREENSAVER=yes])
AC_ARG_ENABLE(xdmcp, AS_HELP_STRING([--disable-xdmcp], [Build XDMCP extension (default: auto)]), [XDMCP=$enableval], [XDMCP=auto])
AC_ARG_ENABLE(xdm-auth-1, AS_HELP_STRING([--disable-xdm-auth-1], [Build XDM-Auth-1 extension (default: auto)]), [XDMAUTH=$enableval], [XDMAUTH=auto])
@ -412,8 +420,8 @@ AC_ARG_ENABLE(aiglx, AS_HELP_STRING([--enable-aiglx], [Build accelerate
AC_ARG_ENABLE(glx-tls, AS_HELP_STRING([--enable-glx-tls], [Build GLX with TLS support (default: disabled)]), [GLX_USE_TLS=$enableval], [GLX_USE_TLS=no])
AC_ARG_ENABLE(dri, AS_HELP_STRING([--enable-dri], [Build DRI extension (default: auto)]), [DRI=$enableval])
AC_ARG_ENABLE(xinerama, AS_HELP_STRING([--disable-xinerama], [Build Xinerama extension (default: enabled)]), [XINERAMA=$enableval], [XINERAMA=yes])
AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: enabled)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=yes])
AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: enabled)]), [XF86MISC=$enableval], [XF86MISC=yes])
AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: auto)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=auto])
AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Misc extension (default: auto)]), [XF86MISC=$enableval], [XF86MISC=auto])
AC_ARG_ENABLE(xace, AS_HELP_STRING([--disable-xace], [Build X-ACE extension (default: enabled)]), [XACE=$enableval], [XACE=yes])
AC_ARG_ENABLE(xcsecurity, AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: enabled)]), [XCSECURITY=$enableval], [XCSECURITY=$XACE])
AC_ARG_ENABLE(appgroup, AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: enabled)]), [APPGROUP=$enableval], [APPGROUP=$XCSECURITY])
@ -427,7 +435,7 @@ AC_ARG_ENABLE(fontcache, AS_HELP_STRING([--enable-fontcache], [Build FontCa
AC_ARG_ENABLE(dbe, AS_HELP_STRING([--disable-dbe], [Build DBE extension (default: enabled)]), [DBE=$enableval], [DBE=yes])
AC_ARG_ENABLE(xf86bigfont, AS_HELP_STRING([--disable-xf86bigfont], [Build XF86 Big Font extension (default: enabled)]), [XF86BIGFONT=$enableval], [XF86BIGFONT=yes])
AC_ARG_ENABLE(dpms, AS_HELP_STRING([--disable-dpms], [Build DPMS extension (default: enabled)]), [DPMSExtension=$enableval], [DPMSExtension=yes])
AC_ARG_ENABLE(xinput, AS_HELP_STRING([--disable-xinput], [Build XInput Extension (default: enabled)]), [XINPUT=$enableval], [XINPUT=yes])
AC_ARG_ENABLE(dbus, AS_HELP_STRING([--disable-dbus], [Build D-BUS support (default: auto)]), [DBUS=$enableval], [DBUS=auto])
AC_ARG_ENABLE(xfree86-utils, AS_HELP_STRING([--enable-xfree86-utils], [Build xfree86 DDX utilities (default: enabled)]), [XF86UTILS=$enableval], [XF86UTILS=yes])
dnl DDXes.
@ -444,6 +452,9 @@ dnl kdrive and its subsystems
AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
AC_ARG_ENABLE(xsdl, AS_HELP_STRING([--enable-xsdl], [Build the kdrive Xsdl server (default: auto)]), [XSDL=$enableval], [XSDL=auto])
AC_ARG_ENABLE(xfake, AS_HELP_STRING([--enable-xfake], [Build the kdrive 'fake' server (default: auto)]), [XFAKE=$enableval], [XFAKE=auto])
AC_ARG_ENABLE(xfbdev, AS_HELP_STRING([--enable-xfbdev], [Build the kdrive framebuffer device server (default: auto)]), [XFBDEV=$enableval], [XFBDEV=auto])
AC_ARG_ENABLE(kdrive-vesa, AS_HELP_STRING([--enable-kdrive-vesa], [Build the kdrive VESA-based servers (default: auto)]), [KDRIVEVESA=$enableval], [KDRIVEVESA=auto])
dnl xprint
AC_ARG_ENABLE(freetype, AS_HELP_STRING([ --enable-freetype], [Build Xprint FreeType backend (default: yes)]), [XP_USE_FREETYPE=$enableval],[XP_USE_FREETYPE=no])
AC_ARG_WITH(freetype-config, AS_HELP_STRING([ --with-freetype-config=PROG], [Use FreeType configuration program PROG (default: auto)]), freetype_config=$withval, freetype_config=auto)
@ -515,9 +526,21 @@ XEXT_LIB='$(top_builddir)/Xext/libXext.la'
XEXTXORG_LIB='$(top_builddir)/Xext/libXextbuiltin.la'
dnl Core modules for most extensions, et al.
REQUIRED_MODULES="randrproto renderproto [fixesproto >= 4.0] damageproto xcmiscproto xextproto xproto xtrans xf86miscproto xf86vidmodeproto xf86bigfontproto [scrnsaverproto >= 1.1] bigreqsproto resourceproto fontsproto inputproto xf86dgaproto [kbproto >= 1.0.3]"
REQUIRED_MODULES="randrproto renderproto [fixesproto >= 4.0] damageproto xcmiscproto xextproto xproto xtrans [scrnsaverproto >= 1.1] bigreqsproto resourceproto fontsproto [inputproto >= 1.4] [kbproto >= 1.0.3]"
REQUIRED_LIBS="xfont xau fontenc"
if test "x$DBUS" = xauto; then
PKG_CHECK_MODULES(DBUS, dbus-1, [DBUS=yes], [DBUS=no])
fi
if test "x$DBUS" = xyes; then
PKG_CHECK_MODULES(DBUS, dbus-1)
AC_DEFINE(HAVE_DBUS, 1, [Have D-BUS support])
REQUIRED_MODULES="$REQUIRED_MODULES dbus-1"
REQUIRED_LIBS="$REQUIRED_LIBS dbus-1"
fi
CONFIG_LIB='$(top_builddir)/config/libconfig.a'
AM_CONDITIONAL(DBUS, [test "x$DBUS" = xyes])
AM_CONDITIONAL(XV, [test "x$XV" = xyes])
if test "x$XV" = xyes; then
AC_DEFINE(XV, 1, [Support Xv extension])
@ -532,10 +555,6 @@ if test "x$XVMC" = xyes; then
AC_DEFINE(XvMCExtension, 1, [Build XvMC extension])
fi
AM_CONDITIONAL(DGA, [test "x$DGA" = xyes])
if test "x$DGA" = xyes; then
AC_DEFINE(DGA, 1, [Support DGA extension])
fi
AM_CONDITIONAL(COMPOSITE, [test "x$COMPOSITE" = xyes])
if test "x$COMPOSITE" = xyes; then
@ -696,14 +715,6 @@ if test "x$DPMSExtension" = xyes; then
AC_DEFINE(DPMSExtension, 1, [Support DPMS extension])
fi
if test "x$XF86VIDMODE" = xyes; then
AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
fi
if test "x$XF86MISC" = xyes; then
AC_DEFINE(XF86MISC, 1, [Support XFree86 miscellaneous extensions])
fi
if test "x$XPRINT" = xauto; then
PKG_CHECK_MODULES([XPRINTPROTO], [printproto], [XPRINT=yes], [XPRINT=no])
fi
@ -713,6 +724,11 @@ if test "x$XPRINT" = xyes; then
REQUIRED_MODULES="$REQUIRED_MODULES printproto"
fi
if test "x$BUILTIN_FONTS" = xyes; then
AC_DEFINE(BUILTIN_FONTS, 1, [Use only built-in fonts])
AC_DEFINE(NOFONTSERVERACCESS, 1, [Avoid using a font server])
fi
if test "x$XCALIBRATE" = xyes && test "$KDRIVE" = yes; then
AC_DEFINE(XCALIBRATE, 1, [Build XCalibrate extension])
REQUIRED_MODULES="$REQUIRED_MODULES xcalibrateproto"
@ -743,12 +759,9 @@ if test "$COMPOSITE" = yes; then
fi
MIEXT_DAMAGE_INC='-I$(top_srcdir)/miext/damage'
AM_CONDITIONAL(XINPUT, [test "x$XINPUT" = xyes])
if test "x$XINPUT" = xyes; then
AC_DEFINE(XINPUT, 1, [Support X Input extension])
XI_LIB='$(top_builddir)/Xi/libXi.la'
XI_INC='-I$(top_srcdir)/Xi'
fi
AC_DEFINE(XINPUT, 1, [Support X Input extension])
XI_LIB='$(top_builddir)/Xi/libXi.la'
XI_INC='-I$(top_srcdir)/Xi'
AM_CONDITIONAL(XF86UTILS, test "x$XF86UTILS" = xyes)
@ -764,6 +777,10 @@ XKB_STUB_LIB='$(top_builddir)/xkb/libxkbstubs.la'
AC_CHECK_FUNC(strcasecmp, [], AC_DEFINE([NEED_STRCASECMP], 1,
[Do not have `strcasecmp'.]))
if test "x$NULL_ROOT_CURSOR" = xyes; then
AC_DEFINE(NULL_ROOT_CURSOR, 1, [Use an empty root cursor])
fi
PKG_CHECK_MODULES([XDMCP], [xdmcp], [have_libxdmcp="yes"], [have_libxdmcp="no"])
if test "x$have_libxdmcp" = xyes; then
AC_CHECK_LIB(Xdmcp, XdmcpWrap, [have_xdmcpwrap="yes"], [have_xdmcpwrap="no"], [$XDMCP_LIBS])
@ -840,11 +857,13 @@ AC_DEFINE(DDXOSINIT, 1, [Use OsVendorInit])
AC_DEFINE(SERVER_LOCK, 1, [Use a lock to prevent multiple servers on a display])
AC_DEFINE(SMART_SCHEDULE, 1, [Include time-based scheduler])
AC_DEFINE(NO_LIBCWRAPPER, 1, [Define to 1 if modules should avoid the libcwrapper])
AM_CONDITIONAL(DEBUG, test "x$DEBUGGING" = xyes)
if ! test "x$DEBUGGING" = xyes; then
AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
if test "x$DEBUGGING" = xyes; then
AC_DEFINE(DEBUG, 1, [Enable debugging code])
else
AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
fi
AM_CONDITIONAL(DEBUG, [test "x$DEBUGGING" = xyes])
AC_DEFINE(USE_RGB_TXT, 1, [Use rgb.txt directly])
AC_DEFINE(MITMISC, 1, [Support MIT Misc extension])
@ -872,9 +891,32 @@ PKG_CHECK_MODULES([XSERVERCFLAGS], [$REQUIRED_MODULES $REQUIRED_LIBS])
PKG_CHECK_MODULES([XSERVERLIBS], [$REQUIRED_LIBS])
XSERVER_CFLAGS="${XSERVERCFLAGS_CFLAGS}"
XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} -lm"
XSERVER_LIBS="${XSERVERLIBS_LIBS} ${SYS_LIBS} ${LIBS}"
AC_SUBST([SYS_LIBS])
# The Xorg binary needs to export symbols so that they can be used from modules
# Some platforms require extra flags to do this. gcc should set these flags
# when -rdynamic is passed to it, other compilers/linkers may need to be added
# here.
if test "x$GCC" = "xyes"; then
GCC_WARNINGS1="-Wall -Wpointer-arith -Wstrict-prototypes"
GCC_WARNINGS2="-Wmissing-prototypes -Wmissing-declarations"
GCC_WARNINGS3="-Wnested-externs -fno-strict-aliasing"
GCC_WARNINGS="$GCC_WARNINGS1 $GCC_WARNINGS2 $GCC_WARNINGS3"
if test "x$WERROR" = "xyes"; then
GCC_WARNINGS="${GCC_WARNINGS} -Werror"
fi
XSERVER_CFLAGS="$GCC_WARNINGS $XSERVER_CFLAGS"
LD_EXPORT_SYMBOLS_FLAG="-rdynamic"
fi
case $host_os in
openbsd*)
LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-dynamic"
;;
esac
AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
AC_CHECK_FUNCS([clock_gettime], [have_clock_gettime=yes],
[AC_CHECK_LIB([rt], [clock_gettime], [have_clock_gettime=-lrt],
[have_clock_gettime=no])])
@ -883,9 +925,9 @@ AC_MSG_CHECKING([for a useful monotonic clock ...])
if ! test "x$have_clock_gettime" = xno; then
if ! test "x$have_clock_gettime" = xyes; then
LIBS="$have_clock_gettime"
CLOCK_LIBS="$have_clock_gettime"
else
LIBS=""
CLOCK_LIBS=""
fi
AC_RUN_IFELSE([
@ -910,7 +952,8 @@ AC_MSG_RESULT([$MONOTONIC_CLOCK])
if test "x$MONOTONIC_CLOCK" = xyes; then
AC_DEFINE(MONOTONIC_CLOCK, 1, [Have monotonic clock from clock_gettime()])
XSERVER_LIBS="$XSERVER_LIBS $LIBS"
XSERVER_LIBS="$XSERVER_LIBS $CLOCK_LIBS"
LIBS="$LIBS $CLOCK_LIBS"
fi
dnl Imake defines SVR4 on SVR4 systems, and many files check for it, so
@ -988,7 +1031,7 @@ AC_MSG_RESULT([$XVFB])
AM_CONDITIONAL(XVFB, [test "x$XVFB" = xyes])
if test "x$XVFB" = xyes; then
XVFB_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB"
XVFB_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB $LIBS"
AC_SUBST([XVFB_LIBS])
fi
@ -1004,7 +1047,7 @@ AC_MSG_RESULT([$XNEST])
AM_CONDITIONAL(XNEST, [test "x$XNEST" = xyes])
if test "x$XNEST" = xyes; then
XNEST_LIBS="$FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB"
XNEST_LIBS="$XSERVER_LIBS $FB_LIB $MI_LIB $FIXES_LIB $XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XKB_STUB_LIB $COMPOSITE_LIB $XPSTUBS_LIB $CWRAP_LIB $OS_LIB $LIBS"
AC_SUBST([XNEST_LIBS])
fi
@ -1075,7 +1118,7 @@ if test "x$XGLX" = xyes; then
fi
# XORG_CORE_LIBS is needed even if you're not building the Xorg DDX
XORG_CORE_LIBS="$DIX_LIB"
XORG_CORE_LIBS="$DIX_LIB $CONFIG_LIB"
AC_SUBST([XORG_CORE_LIBS])
xorg_bus_linuxpci=no
@ -1093,6 +1136,37 @@ if test "x$XORG" = xyes -o "x$XGL" = xyes; then
XORG_CFLAGS="$XORGSERVER_CFLAGS -DHAVE_XORG_CONFIG_H"
XORG_LIBS="$COMPOSITE_LIB $MI_LIB $FIXES_LIB $XEXTXORG_LIB $GLX_LIBS $RENDER_LIB $RANDR_LIB $DAMAGE_LIB $MIEXT_DAMAGE_LIB $MIEXT_SHADOW_LIB $XI_LIB $XKB_LIB $XPSTUBS_LIB $OS_LIB"
if test "x$DGA" = xauto; then
PKG_CHECK_MODULES(DGA, xf86dgaproto, [DGA=yes], [DGA=no])
fi
if test "x$DGA" = xyes; then
XORG_MODULES="$XORG_MODULES xf86dgaproto"
AC_DEFINE(DGA, 1, [Support DGA extension])
AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
fi
if test "x$XF86MISC" = xauto; then
PKG_CHECK_MODULES(XF86MISC, xf86miscproto, [XF86MISC=yes], [XF86MISC=no])
fi
if test "x$XF86MISC" = xyes; then
XORG_MODULES="$XORG_MODULES xf86miscproto"
AC_DEFINE(XF86MISC, 1, [Support XFree86 miscellaneous extensions])
fi
if test "x$XF86VIDMODE" = xauto; then
PKG_CHECK_MODULES(XF86VIDMODE, xf86vidmodeproto, [XF86VIDMODE=yes], [XF86VIDMODE=no])
fi
if test "x$XF86VIDMODE" = xyes; then
XORG_MODULES="$XORG_MODULES xf86vidmodeproto"
AC_DEFINE(XF86VIDMODE, 1, [Support XFree86 Video Mode extension])
fi
if test -n "$XORG_MODULES"; then
PKG_CHECK_MODULES(XORG_MODULES, [$XORG_MODULES])
XORG_CFLAGS="$XORG_CFLAGS $XORG_MODULES_CFLAGS"
XORG_LIBS="$XORG_LIBS $XORG_MODULES_LIBS"
fi
dnl Check to see if dlopen is in default libraries (like Solaris, which
dnl has it in libc), or if libdl is needed to get it.
AC_CHECK_FUNC([dlopen], [],
@ -1105,7 +1179,6 @@ dnl has it in libc), or if libdl is needed to get it.
fi
XORG_OS="linux"
XORG_OS_SUBDIR="linux"
XORG_OS_KBD="Lnx"
xorg_bus_linuxpci="yes"
linux_acpi="no"
case $host_cpu in
@ -1124,30 +1197,10 @@ dnl has it in libc), or if libdl is needed to get it.
*)
;;
esac
# check whether struct kbd_repeat has the 'period' field.
# on kernels < 2.5.42 it's called 'rate' instead.
AC_TRY_COMPILE([
#include <linux/kd.h>
#ifdef __sparc__
#include <asm/param.h>
#include <asm/kbio.h>
#endif
],[
int main () {
struct kbd_repeat k;
k.period = 0;
return 0;
}],
[period_field="period"],
[period_field="rate"])
AC_DEFINE_UNQUOTED(LNX_KBD_PERIOD_NAME, [$period_field],
[Name of the period field in struct kbd_repeat])
;;
freebsd* | kfreebsd*-gnu)
XORG_OS="freebsd"
XORG_OS_SUBDIR="bsd"
XORG_OS_KBD="BSD"
case $host_cpu in
i*86)
;;
@ -1159,7 +1212,6 @@ int main () {
netbsd*)
XORG_OS="netbsd"
XORG_OS_SUBDIR="bsd"
XORG_OS_KBD="BSD"
case $host_cpu in
i*86|amd64*|x86_64*|ia64*)
;;
@ -1171,7 +1223,6 @@ int main () {
openbsd*)
XORG_OS="openbsd"
XORG_OS_SUBDIR="bsd"
XORG_OS_KBD="BSD"
case $host_cpu in
i*86|amd64*|x86_64*|ia64*)
;;
@ -1278,7 +1329,6 @@ int main () {
AC_SUBST([XORG_INCS])
AC_SUBST([XORG_OS])
AC_SUBST([XORG_OS_SUBDIR])
AC_SUBST([XORG_OS_KBD])
dnl only used in hw/xfree86/scanpci, TTBOMK
AC_PATH_PROG(PERL, perl, no)
@ -1288,28 +1338,7 @@ int main () {
fi
AC_SUBST(PERL)
# The Xorg binary needs to export symbols so that they can be used from modules
# Some platforms require extra flags to do this. gcc should set these flags
# when -rdynamic is passed to it, other compilers/linkers may need to be added
# here.
if test "x$GCC" = "xyes"; then
GCC_WARNINGS1="-Wall -Wpointer-arith -Wstrict-prototypes"
GCC_WARNINGS2="-Wmissing-prototypes -Wmissing-declarations"
GCC_WARNINGS3="-Wnested-externs -fno-strict-aliasing"
GCC_WARNINGS="$GCC_WARNINGS1 $GCC_WARNINGS2 $GCC_WARNINGS3"
if test "x$WERROR" = "xyes"; then
GCC_WARNINGS="${GCC_WARNINGS} -Werror"
fi
XSERVER_CFLAGS="$GCC_WARNINGS $XSERVER_CFLAGS"
LD_EXPORT_SYMBOLS_FLAG="-rdynamic"
fi
case $host_os in
openbsd*)
LD_EXPORT_SYMBOLS_FLAG="-Wl,--export-dynamic"
;;
esac
AC_SUBST([XORG_CFLAGS])
AC_SUBST([LD_EXPORT_SYMBOLS_FLAG])
dnl these only go in xorg-config.h
XF86CONFIGFILE="xorg.conf"
@ -1358,6 +1387,7 @@ AM_CONDITIONAL([SOLARIS_ASM_INLINE], [test "x$solaris_asm_inline" = xyes])
AM_CONDITIONAL(MFB, [test "x$XORG" = xyes])
AM_CONDITIONAL(CFB, [test "x$XORG" = xyes])
AM_CONDITIONAL(AFB, [test "x$XORG" = xyes])
AM_CONDITIONAL(DGA, [test "x$DGA" = xyes])
dnl Xprint DDX
@ -1367,7 +1397,7 @@ AC_MSG_RESULT([$XPRINT])
if test "x$XPRINT" = xyes; then
PKG_CHECK_MODULES([XPRINT], [printproto x11 xfont $XDMCP_MODULES xau])
XPRINT_EXTENSIONS="$XEXT_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $RENDER_LIB $COMPOSITE_LIB $RANDR_LIB $XI_LIB $FIXES_LIB $DAMAGE_LIB $XI_LIB $GLX_LIBS"
XPRINT_LIBS="$XPRINT_LIBS $DIX_LIB $XKB_LIB $XKB_STUB_LIB $XPRINT_EXTENSIONS $MI_LIB $MIEXT_DAMAGE_LIB $CWRAP_LIB $OS_LIB"
XPRINT_LIBS="$XPRINT_LIBS $DIX_LIB $CONFIG_LIB $XKB_LIB $XKB_STUB_LIB $XPRINT_EXTENSIONS $MI_LIB $MIEXT_DAMAGE_LIB $CWRAP_LIB $OS_LIB $LIBS"
AC_SUBST([XPRINT_CFLAGS])
AC_SUBST([XPRINT_LIBS])
@ -1496,16 +1526,59 @@ if test "$KDRIVE" = yes; then
AC_DEFINE(KDRIVEDDXACTIONS,,[Build kdrive ddx])
AC_CHECK_HEADERS([sys/vm86.h sys/io.h])
if test "$ac_cv_header_sys_vm86_h" = yes; then
if test "$ac_cv_header_sys_vm86_h" = yes && test "x$KDRIVEVESA" = xauto; then
KDRIVEVESA=yes
fi
if test "x$KDRIVEVESA" = xyes; then
KDRIVEFBDEVLIB=yes
AC_DEFINE(KDRIVEVESA, 1, [Build VESA-based kdrive servers])
fi
AC_CHECK_HEADERS([linux/fb.h])
if test "$ac_cv_header_linux_fb_h" = yes; then
if test "$ac_cv_header_linux_fb_h" = yes && test "x$XFBDEV" = xauto; then
XFBDEV=yes
fi
if test "x$XFBDEV" = xyes; then
KDRIVEFBDEVLIB=yes
AC_DEFINE(KDRIVEFBDEV, 1, [Build fbdev-based kdrive server])
fi
# tslib...
AC_CHECK_LIB(ts, ts_open, [HAVE_TSLIB="yes"])
if test "x$TSLIB" = xauto && test "x$HAVE_TSLIB" = xyes; then
TSLIB=yes
fi
if test "x$TSLIB" = xyes; then
if ! test "x$HAVE_TSLIB" = xyes; then
AC_MSG_ERROR([tslib must be installed to build the tslib input driver.])
fi
TSLIB_LIBS="-lts"
AC_DEFINE(TSLIB, 1, [Have tslib support])
fi
if test x"$ac_cv_header_SDL_SDL_h" = xyes && test "x$XSDL" = xauto; then
XSDL=yes
fi
if test x"$XSDL" = xyes; then
# PKG_CHECK_MODULES(XSDL_EXTRA, Xfont xau $XDMCP_MODULES)
AC_DEFINE(XSDLSERVER,1,[Build Xsdl server])
XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
fi
PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
if test "x$XEPHYR" = xauto; then
XEPHYR=$xephyr
fi
# Xephyr needs nanosleep() which is in librt on Solaris
AC_CHECK_FUNC([nanosleep], [],
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
if test "x$TSLIB" = xyes; then
PKG_CHECK_MODULES([TSLIB], [tslib-0.0], [HAVE_TSLIB="yes"], [HAVE_TSLIB="no"])
if test "x$HAVE_TSLIB" = xno; then
@ -1529,53 +1602,49 @@ if test "$KDRIVE" = yes; then
KDRIVE_LIB='$(top_builddir)/hw/kdrive/src/libkdrive.a'
KDRIVE_OS_LIB='$(top_builddir)/hw/kdrive/linux/liblinux.a'
KDRIVE_STUB_LIB='$(top_builddir)/hw/kdrive/src/libkdrivestubs.a'
KDRIVE_LIBS="$DIX_LIB $KDRIVE_LIB $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB $TSLIB_LIBS"
KDRIVE_LIBS="$XSERVERLIBS_LIBS $DIX_LIB $CONFIG_LIB $KDRIVE_LIB $TSLIB_LIBS $KDRIVE_OS_LIB $KDRIVE_PURE_LIBS $KDRIVE_STUB_LIB"
# check if we can build Xephyr
PKG_CHECK_MODULES(XEPHYR, x11 xext xfont xau xdmcp, [xephyr="yes"], [xephyr="no"])
XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
# Xephyr needs nanosleep() which is in librt on Solaris
AC_CHECK_FUNC([nanosleep], [],
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
# check for SDL SDK
AC_CHECK_HEADERS([SDL/SDL.h])
if test "x$XSDL" = xauto; then
XSDL="$ac_cv_header_SDL_SDL_h"
fi
AC_SUBST([XEPHYR_LIBS])
AC_SUBST([XEPHYR_INCS])
AC_SUBST([XSDL_LIBS])
AC_SUBST([XSDL_INCS])
fi
AC_SUBST(KDRIVE_INCS)
AC_SUBST(KDRIVE_PURE_INCS)
AC_SUBST(KDRIVE_CFLAGS)
AC_SUBST(KDRIVE_PURE_LIBS)
AC_SUBST(KDRIVE_LIBS)
AC_SUBST([KDRIVE_INCS])
AC_SUBST([KDRIVE_PURE_INCS])
AC_SUBST([KDRIVE_CFLAGS])
AC_SUBST([KDRIVE_PURE_LIBS])
AC_SUBST([KDRIVE_LIBS])
AM_CONDITIONAL(TSLIB, [test "x$HAVE_TSLIB" = xyes])
AM_CONDITIONAL(H3600_TS, false)
AM_CONDITIONAL(KDRIVEVESA, [test "x$KDRIVEVESA" = xyes])
AM_CONDITIONAL(KDRIVEFBDEV, [test "x$XFBDEV" = xyes])
AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
AM_CONDITIONAL(XEPHYR, [test "x$KDRIVE" = xyes && test "x$XEPHYR" = xyes])
AM_CONDITIONAL(BUILD_KDRIVEFBDEVLIB, [test "x$KDRIVE" = xyes && test "x$KDRIVEFBDEVLIB" = xyes])
AM_CONDITIONAL(XFAKESERVER, [test "x$KDRIVE" = xyes && test "x$XFAKE" = xyes])
AM_CONDITIONAL(KDRIVEVESA, [test x"$ac_cv_header_sys_vm86_h" = xyes])
AM_CONDITIONAL(KDRIVEFBDEV, [test x"$ac_cv_header_linux_fb_h" = xyes])
# Xephyr needs nanosleep() which is in librt on Solaris
AC_CHECK_FUNC([nanosleep], [],
AC_CHECK_LIB([rt], [nanosleep], XEPHYR_LIBS="$XEPHYR_LIBS -lrt"))
AM_CONDITIONAL(XEPHYR, [test x"$xephyr" = xyes])
XEPHYR_LIBS="$XEPHYR_LIBS $XSERVER_LIBS"
AC_SUBST([XEPHYR_LIBS])
AC_SUBST([XEPHYR_INCS])
if test x"$XSDL" = xyes; then
AC_DEFINE(XSDLSERVER,,[Build Xsdl server])
XSDL_LIBS="`sdl-config --libs` $XSERVER_LIBS"
XSDL_INCS="`sdl-config --cflags` $XSERVER_CFLAGS"
fi
AM_CONDITIONAL(XSDLSERVER, [test x"$XSDL" = xyes])
AC_SUBST([XSDL_LIBS])
AC_SUBST([XSDL_INCS])
dnl these only go in xkb-config.h (which is shared by the Xorg and Xnest servers)
AC_DEFINE(__XKBDEFRULES__, "xorg", [Default XKB rules])
AC_DEFINE_DIR(XKB_BASE_DIRECTORY, XKBPATH, [Path to XKB data])
AC_DEFINE_DIR(XKB_BIN_DIRECTORY, bindir, [Path to XKB bin dir])
# Make sure XKM_OUTPUT_DIR is an absolute path
XKBOUTPUT_FIRSTCHAR=`echo $XKBOUTPUT | cut -b 1`
if [[ x$XKBOUTPUT_FIRSTCHAR != x/ ]] ; then
@ -1593,7 +1662,6 @@ AC_DEFINE_DIR(XKM_OUTPUT_DIR, XKBOUTPUT, [Path to XKB output dir])
AC_SUBST(XKB_COMPILED_DIR)
dnl and the rest of these are generic, so they're in config.h
AC_DEFINE(XFreeXDGA, 1, [Build XDGA support])
AC_DEFINE(XResExtension, 1, [Build XRes extension])
dnl CYGWIN does not define fd_set if _POSIX_SOURCE is defined
@ -1614,9 +1682,11 @@ esac
AC_DEFINE_DIR(PROJECTROOT, prefix, [Overall prefix])
dnl xorgconfig CLI configuration utility
PKG_CHECK_MODULES([XORGCONFIG_DEP], [xkbfile x11])
AC_SUBST(XORGCONFIG_DEP_CFLAGS)
AC_SUBST(XORGCONFIG_DEP_LIBS)
if test "x$XORG" = xyes; then
PKG_CHECK_MODULES([XORGCONFIG_DEP], [xkbfile x11])
AC_SUBST(XORGCONFIG_DEP_CFLAGS)
AC_SUBST(XORGCONFIG_DEP_LIBS)
fi
dnl xorgcfg GUI configuration utility
AC_ARG_ENABLE(xorgcfg, AS_HELP_STRING([--enable-xorgcfg],
@ -1708,6 +1778,7 @@ XTrap/Makefile
mfb/Makefile
cfb/Makefile
cfb32/Makefile
config/Makefile
mi/Makefile
miext/Makefile
miext/damage/Makefile

1
dix/Makefile.am
View File

@ -17,6 +17,7 @@ libdix_la_SOURCES = \
extension.c \
ffs.c \
gc.c \
getevents.c \
globals.c \
glyphcurs.c \
grabs.c \

953
dix/devices.c
View File

File diff suppressed because it is too large Load Diff

4
dix/dispatch.c
View File

@ -100,6 +100,7 @@ int ProcInitialConnection();
#include "dispatch.h"
#include "swaprep.h"
#include "swapreq.h"
#include "config.h"
#ifdef PANORAMIX
#include "panoramiX.h"
#include "panoramiXsrv.h"
@ -382,6 +383,9 @@ Dispatch(void)
nready = WaitForSomething(clientReady);
/* this is an enormous hack and NEEDS TO GO AWAY. */
configDispatch();
#ifdef SMART_SCHEDULE
if (nready && !SmartScheduleDisable)
{

65
dix/dixfonts.c
View File

@ -155,11 +155,6 @@ QueueFontWakeup(FontPathElementPtr fpe)
for (i = 0; i < num_slept_fpes; i++) {
if (slept_fpes[i] == fpe) {
#ifdef DEBUG
fprintf(stderr, "re-queueing fpe wakeup\n");
#endif
return;
}
}
@ -1886,7 +1881,7 @@ InitFonts ()
{
patternCache = MakeFontPatternCache();
#ifndef KDRIVESERVER
#ifndef BUILTIN_FONTS
if (screenInfo.numScreens > screenInfo.numVideoScreens) {
PrinterFontRegisterFpeFunctions();
FontFileCheckRegisterFpeFunctions();
@ -1894,10 +1889,11 @@ InitFonts ()
} else
#endif
{
#ifdef KDRIVESERVER
BuiltinRegisterFpeFunctions();
#endif
#ifdef BUILTIN_FONTS
BuiltinRegisterFpeFunctions();
#else
FontFileRegisterFpeFunctions();
#endif
#ifndef NOFONTSERVERACCESS
fs_register_fpe_functions();
#endif
@ -2059,11 +2055,6 @@ init_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler)
fs_handlers_installed = 0;
}
if (fs_handlers_installed == 0) {
#ifdef DEBUG
fprintf(stderr, "adding FS b & w handlers\n");
#endif
if (!RegisterBlockAndWakeupHandlers(block_handler,
FontWakeup, (pointer) 0))
return AllocError;
@ -2079,55 +2070,9 @@ remove_fs_handlers(FontPathElementPtr fpe, BlockHandlerProcPtr block_handler, Bo
if (all) {
/* remove the handlers if no one else is using them */
if (--fs_handlers_installed == 0) {
#ifdef DEBUG
fprintf(stderr, "removing FS b & w handlers\n");
#endif
RemoveBlockAndWakeupHandlers(block_handler, FontWakeup,
(pointer) 0);
}
}
RemoveFontWakeup(fpe);
}
#ifdef DEBUG
#define GLWIDTHBYTESPADDED(bits,nbytes) \
((nbytes) == 1 ? (((bits)+7)>>3) /* pad to 1 byte */ \
:(nbytes) == 2 ? ((((bits)+15)>>3)&~1) /* pad to 2 bytes */ \
:(nbytes) == 4 ? ((((bits)+31)>>3)&~3) /* pad to 4 bytes */ \
:(nbytes) == 8 ? ((((bits)+63)>>3)&~7) /* pad to 8 bytes */ \
: 0)
#define GLYPH_SIZE(ch, nbytes) \
GLWIDTHBYTESPADDED((ch)->metrics.rightSideBearing - \
(ch)->metrics.leftSideBearing, (nbytes))
void
dump_char_ascii(CharInfoPtr cip)
{
int r,
l;
int bpr;
int byte;
static unsigned maskTab[] = {
(1 << 7), (1 << 6), (1 << 5), (1 << 4),
(1 << 3), (1 << 2), (1 << 1), (1 << 0),
};
bpr = GLYPH_SIZE(cip, 4);
for (r = 0; r < (cip->metrics.ascent + cip->metrics.descent); r++) {
pointer row = (pointer) cip->bits + r * bpr;
byte = 0;
for (l = 0; l <= (cip->metrics.rightSideBearing -
cip->metrics.leftSideBearing); l++) {
if (maskTab[l & 7] & row[l >> 3])
putchar('X');
else
putchar('.');
}
putchar('\n');
}
}
#endif

75
dix/events.c
View File

@ -113,6 +113,7 @@ of the copyright holder.
#endif
#include <X11/X.h>
#include <X11/keysym.h>
#include "misc.h"
#include "resource.h"
#define NEED_EVENTS
@ -131,6 +132,7 @@ of the copyright holder.
#include "globals.h"
#ifdef XKB
#include <X11/extensions/XKBproto.h>
#include <X11/extensions/XKBsrv.h>
extern Bool XkbFilterEvents(ClientPtr, int, xEvent *);
#endif
@ -154,7 +156,9 @@ xEvent *xeviexE;
#endif
#include <X11/extensions/XIproto.h>
#include "exglobals.h"
#include "exevents.h"
#include "exglobals.h"
#include "extnsionst.h"
#include "dixevents.h"
@ -206,9 +210,6 @@ _X_EXPORT CallbackListPtr DeviceEventCallback;
Mask DontPropagateMasks[DNPMCOUNT];
static int DontPropagateRefCnts[DNPMCOUNT];
#ifdef DEBUG
static debug_events = 0;
#endif
_X_EXPORT InputInfo inputInfo;
static struct {
@ -319,11 +320,16 @@ static CARD8 criticalEvents[32] =
};
#ifdef PANORAMIX
static void ConfineToShape(RegionPtr shape, int *px, int *py);
static void SyntheticMotion(int x, int y);
static void PostSyntheticMotion(int x, int y, int screenNum, int time);
static void PostNewCursor(void);
#define SyntheticMotion(x, y) \
PostSyntheticMotion(x, y, sprite.screen->myNum, \
syncEvents.playingEvents ? \
syncEvents.time.milliseconds : \
currentTime.milliseconds);
static Bool
XineramaSetCursorPosition(
int x,
@ -666,30 +672,6 @@ SetCriticalEvent(int event)
criticalEvents[event >> 3] |= 1 << (event & 7);
}
static void
SyntheticMotion(int x, int y)
{
xEvent xE;
#ifdef PANORAMIX
/* Translate back to the sprite screen since processInputProc
will translate from sprite screen to screen 0 upon reentry
to the DIX layer */
if(!noPanoramiXExtension) {
x += panoramiXdataPtr[0].x - panoramiXdataPtr[sprite.screen->myNum].x;
y += panoramiXdataPtr[0].y - panoramiXdataPtr[sprite.screen->myNum].y;
}
#endif
xE.u.keyButtonPointer.rootX = x;
xE.u.keyButtonPointer.rootY = y;
if (syncEvents.playingEvents)
xE.u.keyButtonPointer.time = syncEvents.time.milliseconds;
else
xE.u.keyButtonPointer.time = currentTime.milliseconds;
xE.u.u.type = MotionNotify;
(*inputInfo.pointer->public.processInputProc)(&xE, inputInfo.pointer, 1);
}
#ifdef SHAPE
static void
ConfineToShape(RegionPtr shape, int *px, int *py)
@ -1531,9 +1513,8 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
int i;
int type;
#ifdef DEBUG
if (debug_events) ErrorF(
"Event([%d, %d], mask=0x%x), client=%d",
#ifdef DEBUG_EVENTS
ErrorF("Event([%d, %d], mask=0x%x), client=%d",
pEvents->u.u.type, pEvents->u.u.detail, mask, client->index);
#endif
if ((client) && (client != serverClient) && (!client->clientGone) &&
@ -1549,9 +1530,9 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
if (WID(inputInfo.pointer->valuator->motionHintWindow) ==
pEvents->u.keyButtonPointer.event)
{
#ifdef DEBUG
if (debug_events) ErrorF("\n");
fprintf(stderr,"motionHintWindow == keyButtonPointer.event\n");
#ifdef DEBUG_EVENTS
ErrorF("\n");
ErrorF("motionHintWindow == keyButtonPointer.event\n");
#endif
return 1; /* don't send, but pretend we did */
}
@ -1589,15 +1570,15 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
}
WriteEventsToClient(client, count, pEvents);
#ifdef DEBUG
if (debug_events) ErrorF( " delivered\n");
#ifdef DEBUG_EVENTS
ErrorF( " delivered\n");
#endif
return 1;
}
else
{
#ifdef DEBUG
if (debug_events) ErrorF("\n");
#ifdef DEBUG_EVENTS
ErrorF("\n");
#endif
return 0;
}
@ -2776,13 +2757,6 @@ drawable.id:0;
}
#endif
#ifdef DEBUG
if ((xkbDebugFlags&0x4)&&
((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
ErrorF("CoreProcessKbdEvent: Key %d %s\n",key,
(xE->u.u.type==KeyPress?"down":"up"));
}
#endif
switch (xE->u.u.type)
{
case KeyPress:
@ -2867,13 +2841,12 @@ FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
key = xE->u.u.detail;
kptr = &keyc->down[key >> 3];
bit = 1 << (key & 7);
#ifdef DEBUG
if ((xkbDebugFlags&0x4)&&
((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
ErrorF("FixKeyState: Key %d %s\n",key,
if (((xE->u.u.type==KeyPress)||(xE->u.u.type==KeyRelease))) {
DebugF("FixKeyState: Key %d %s\n",key,
(xE->u.u.type==KeyPress?"down":"up"));
}
#endif
switch (xE->u.u.type)
{
case KeyPress:

781
dix/getevents.c Normal file
View File

@ -0,0 +1,781 @@
/*
* Copyright © 2006 Nokia Corporation
*
* 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 this copyright notice and this permission notice appear in
* supporting electronic documentation.
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR AUTHORS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Author: Daniel Stone <daniel@fooishbar.org>
*/
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <X11/X.h>
#include <X11/keysym.h>
#include "misc.h"
#include "resource.h"
#define NEED_EVENTS
#define NEED_REPLIES
#include <X11/Xproto.h>
#include "inputstr.h"
#include "scrnintstr.h"
#include "cursorstr.h"
#include "dixstruct.h"
#include "globals.h"
#include "mipointer.h"
#ifdef XKB
#include <X11/extensions/XKBproto.h>
#include <X11/extensions/XKBsrv.h>
extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
#endif
#ifdef XACE
#include "xace.h"
#endif
#ifdef PANORAMIX
#include "panoramiX.h"
#include "panoramiXsrv.h"
#endif
#include <X11/extensions/XI.h>
#include <X11/extensions/XIproto.h>
#include "exglobals.h"
#include "exevents.h"
#include "exglobals.h"
#include "extnsionst.h"
/* Maximum number of valuators, divided by six, rounded up. */
#define MAX_VALUATOR_EVENTS 6
/* Number of motion history events to store. */
#define MOTION_HISTORY_SIZE 256
/**
* Returns the maximum number of events GetKeyboardEvents,
* GetKeyboardValuatorEvents, and GetPointerEvents will ever return.
*
* Should be used in DIX as:
* xEvent *events = xcalloc(sizeof(xEvent), GetMaximumEventsNum());
*/
_X_EXPORT int
GetMaximumEventsNum() {
/* Two base events -- core and device, plus valuator events. Multiply
* by two if we're doing key repeats. */
int ret = 2 + MAX_VALUATOR_EVENTS;
#ifdef XKB
if (noXkbExtension)
#endif
ret *= 2;
return ret;
}
/**
* Convenience wrapper around GetKeyboardValuatorEvents, that takes no
* valuators.
*/
_X_EXPORT int
GetKeyboardEvents(xEvent *events, DeviceIntPtr pDev, int type, int key_code) {
return GetKeyboardValuatorEvents(events, pDev, type, key_code, 0, 0, NULL);
}
/**
* Returns a set of keyboard events for KeyPress/KeyRelease, optionally
* also with valuator events. Handles Xi and XKB.
*
* events is not NULL-terminated; the return value is the number of events.
* The DDX is responsible for allocating the event structure in the first
* place via GetMaximumEventsNum(), and for freeing it.
*
* This function does not change the core keymap to that of the device;
* that is done by SwitchCoreKeyboard, which is called from
* mieqProcessInputEvents. If replacing function, take care to call
* SetCoreKeyboard before processInputProc, so keymaps are altered to suit.
*
* Note that this function recurses! If called for non-XKB, a repeating
* key press will trigger a matching KeyRelease, as well as the
* KeyPresses.
*/
_X_EXPORT int
GetKeyboardValuatorEvents(xEvent *events, DeviceIntPtr pDev, int type,
int key_code, int first_valuator,
int num_valuators, int *valuators) {
int numEvents = 0, i = 0;
CARD32 ms = 0;
int final_valuator = first_valuator + num_valuators;
KeySym sym = pDev->key->curKeySyms.map[key_code *
pDev->key->curKeySyms.mapWidth];
deviceKeyButtonPointer *kbp = NULL;
deviceValuator *xv = NULL;
if (!events)
return 0;
if (type != KeyPress && type != KeyRelease)
return 0;
if (!pDev->key || !pDev->focus || !pDev->kbdfeed ||
(pDev->coreEvents && !inputInfo.keyboard->key))
return 0;
if (pDev->coreEvents)
numEvents = 2;
else
numEvents = 1;
if (num_valuators) {
if ((num_valuators / 6) + 1 > MAX_VALUATOR_EVENTS)
num_valuators = MAX_VALUATOR_EVENTS;
numEvents += (num_valuators / 6) + 1;
}
#ifdef XKB
if (noXkbExtension)
#endif
{
switch (sym) {
case XK_Num_Lock:
case XK_Caps_Lock:
case XK_Scroll_Lock:
case XK_Shift_Lock:
if (type == KeyRelease)
return 0;
else if (type == KeyPress &&
(pDev->key->down[key_code >> 3] & (key_code & 7)) & 1)
type = KeyRelease;
}
}
/* Handle core repeating, via press/release/press/release.
* FIXME: In theory, if you're repeating with two keyboards,
* you could get unbalanced events here. */
if (type == KeyPress &&
(((pDev->key->down[key_code >> 3] & (key_code & 7))) & 1)) {
if (!pDev->kbdfeed->ctrl.autoRepeat ||
pDev->key->modifierMap[key_code] ||
!(pDev->kbdfeed->ctrl.autoRepeats[key_code >> 3]
& (1 << (key_code & 7))))
return 0;
#ifdef XKB
if (noXkbExtension)
#endif
{
numEvents += GetKeyboardValuatorEvents(events, pDev,
KeyRelease, key_code,
first_valuator, num_valuators,
valuators);
events += numEvents;
}
}
ms = GetTimeInMillis();
kbp = (deviceKeyButtonPointer *) events;
kbp->time = ms;
kbp->deviceid = pDev->id;
if (type == KeyPress)
kbp->type = DeviceKeyPress;
else if (type == KeyRelease)
kbp->type = DeviceKeyRelease;
if (num_valuators) {
kbp->deviceid |= MORE_EVENTS;
for (i = first_valuator; i < final_valuator; i += 6) {
xv = (deviceValuator *) ++events;
xv->type = DeviceValuator;
xv->first_valuator = i;
xv->num_valuators = num_valuators;
xv->deviceid = kbp->deviceid;
switch (num_valuators - first_valuator) {
case 6:
xv->valuator5 = valuators[i+5];
case 5:
xv->valuator4 = valuators[i+4];
case 4:
xv->valuator3 = valuators[i+3];
case 3:
xv->valuator2 = valuators[i+2];
case 2:
xv->valuator1 = valuators[i+1];
case 1:
xv->valuator0 = valuators[i];
}
}
}
if (pDev->coreEvents) {
events++;
events->u.keyButtonPointer.time = ms;
events->u.u.type = type;
events->u.u.detail = key_code;
}
return numEvents;
}
/* Originally a part of xf86PostMotionEvent; modifies valuators
* in-place. */
static void
acceleratePointer(DeviceIntPtr pDev, int first_valuator, int num_valuators,
int *valuators)
{
float mult = 0.0;
int dx = 0, dy = 0;
int *px = NULL, *py = NULL;
if (!num_valuators || !valuators)
return;
if (first_valuator == 0) {
dx = valuators[0];
px = &valuators[0];
}
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
dy = valuators[1 - first_valuator];
py = &valuators[1 - first_valuator];
}
if (!dx && !dy)
return;
if (pDev->ptrfeed && pDev->ptrfeed->ctrl.num) {
/* modeled from xf86Events.c */
if (pDev->ptrfeed->ctrl.threshold) {
if ((abs(dx) + abs(dy)) >= pDev->ptrfeed->ctrl.threshold) {
pDev->valuator->dxremaind = ((float)dx *
(float)(pDev->ptrfeed->ctrl.num)) /
(float)(pDev->ptrfeed->ctrl.den) +
pDev->valuator->dxremaind;
if (px) {
*px = (int)pDev->valuator->dxremaind;
pDev->valuator->dxremaind = pDev->valuator->dxremaind -
(float)(*px);
}
pDev->valuator->dyremaind = ((float)dy *
(float)(pDev->ptrfeed->ctrl.num)) /
(float)(pDev->ptrfeed->ctrl.den) +
pDev->valuator->dyremaind;
if (py) {
*py = (int)pDev->valuator->dyremaind;
pDev->valuator->dyremaind = pDev->valuator->dyremaind -
(float)(*py);
}
}
}
else {
mult = pow((float)(dx * dx + dy * dy),
((float)(pDev->ptrfeed->ctrl.num) /
(float)(pDev->ptrfeed->ctrl.den) - 1.0) /
2.0) / 2.0;
if (dx) {
pDev->valuator->dxremaind = mult * (float)dx +
pDev->valuator->dxremaind;
*px = (int)pDev->valuator->dxremaind;
pDev->valuator->dxremaind = pDev->valuator->dxremaind -
(float)(*px);
}
if (dy) {
pDev->valuator->dyremaind = mult * (float)dy +
pDev->valuator->dyremaind;
*py = (int)pDev->valuator->dyremaind;
pDev->valuator->dyremaind = pDev->valuator->dyremaind -
(float)(*py);
}
}
}
}
/**
* Clip an axis to its bounds.
*/
static void
clipAxis(DeviceIntPtr pDev, int axisNum, int *val)
{
AxisInfoPtr axes = pDev->valuator->axes + axisNum;
if (*val < axes->min_value)
*val = axes->min_value;
if (axes->max_value >= 0 && *val > axes->max_value)
*val = axes->max_value;
}
/**
* Compare the list of valuators against the limits for each axis, and clip
* them to those bounds.
*/
static void
clipValuators(DeviceIntPtr pDev, int first_valuator, int num_valuators,
int *valuators)
{
AxisInfoPtr axes = pDev->valuator->axes + first_valuator;
int i;
for (i = 0; i < num_valuators; i++, axes++)
clipAxis(pDev, i + first_valuator, &(valuators[i]));
}
/**
* Fills events with valuator events for pDev, as given by the other
* parameters.
*/
static xEvent *
getValuatorEvents(xEvent *events, DeviceIntPtr pDev, int first_valuator,
int num_valuators, int *valuators) {
deviceValuator *xv = (deviceValuator *) events;
int i = 0, final_valuator = first_valuator + num_valuators;
for (i = first_valuator; i < final_valuator; i += 6, xv++, events++) {
xv->type = DeviceValuator;
xv->first_valuator = i;
xv->num_valuators = num_valuators;
xv->deviceid = pDev->id;
switch (final_valuator - i) {
case 6:
xv->valuator5 = valuators[i + 5];
case 5:
xv->valuator4 = valuators[i + 4];
case 4:
xv->valuator3 = valuators[i + 3];
case 3:
xv->valuator2 = valuators[i + 2];
case 2:
xv->valuator1 = valuators[i + 1];
case 1:
xv->valuator0 = valuators[i];
}
if (i + 6 < final_valuator)
xv->deviceid |= MORE_EVENTS;
}
return events;
}
/**
* Pick some arbitrary size for Xi motion history.
*/
_X_EXPORT int
GetMotionHistorySize()
{
return MOTION_HISTORY_SIZE;
}
/**
* Allocate the motion history buffer.
*/
_X_EXPORT void
AllocateMotionHistory(DeviceIntPtr pDev)
{
if (pDev->valuator->motion)
xfree(pDev->valuator->motion);
if (pDev->valuator->numMotionEvents < 1)
return;
pDev->valuator->motion = xalloc(((sizeof(INT32) * pDev->valuator->numAxes) +
sizeof(Time)) *
pDev->valuator->numMotionEvents);
pDev->valuator->first_motion = 0;
pDev->valuator->last_motion = 0;
}
/**
* Dump the motion history between start and stop into the supplied buffer.
* Only records the event for a given screen in theory, but in practice, we
* sort of ignore this.
*/
_X_EXPORT int
GetMotionHistory(DeviceIntPtr pDev, xTimecoord *buff, unsigned long start,
unsigned long stop, ScreenPtr pScreen)
{
int i = 0, ret = 0;
/* The size of a single motion event. */
int size = (sizeof(INT32) * pDev->valuator->numAxes) + sizeof(Time);
Time current;
char *ibuff = NULL, *obuff = (char *) buff;
if (!pDev->valuator || !pDev->valuator->numMotionEvents)
return 0;
for (i = pDev->valuator->first_motion;
i != pDev->valuator->last_motion;
i = (i + 1) % pDev->valuator->numMotionEvents) {
/* We index the input buffer by which element we're accessing, which
* is not monotonic, and the output buffer by how many events we've
* written so far. */
ibuff = (char *) pDev->valuator->motion + (i * size);
memcpy(&current, ibuff, sizeof(Time));
if (current > stop) {
return ret;
}
else if (current >= start) {
memcpy(obuff, ibuff, size);
obuff += size;
ret++;
}
}
return ret;
}
/**
* Update the motion history for a specific device, with the list of
* valuators.
*/
static void
updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, int first_valuator,
int num_valuators, int *valuators)
{
char *buff = (char *) pDev->valuator->motion;
if (!pDev->valuator->numMotionEvents)
return;
buff += ((sizeof(INT32) * pDev->valuator->numAxes) + sizeof(CARD32)) *
pDev->valuator->last_motion;
memcpy(buff, &ms, sizeof(Time));
buff += sizeof(Time);
bzero(buff, sizeof(INT32) * pDev->valuator->numAxes);
buff += sizeof(INT32) * first_valuator;
memcpy(buff, valuators, sizeof(INT32) * num_valuators);
pDev->valuator->last_motion = (pDev->valuator->last_motion + 1) %
pDev->valuator->numMotionEvents;
/* If we're wrapping around, just keep the circular buffer going. */
if (pDev->valuator->first_motion == pDev->valuator->last_motion)
pDev->valuator->first_motion = (pDev->valuator->first_motion + 1) %
pDev->valuator->numMotionEvents;
return;
}
/**
* Generate a series of xEvents (returned in xE) representing pointer
* motion, or button presses. Xi and XKB-aware.
*
* events is not NULL-terminated; the return value is the number of events.
* The DDX is responsible for allocating the event structure in the first
* place via GetMaximumEventsNum(), and for freeing it.
*/
_X_EXPORT int
GetPointerEvents(xEvent *events, DeviceIntPtr pDev, int type, int buttons,
int flags, int first_valuator, int num_valuators,
int *valuators) {
int num_events = 0, final_valuator = 0;
CARD32 ms = 0;
deviceKeyButtonPointer *kbp = NULL;
Bool sendValuators = (type == MotionNotify || flags & POINTER_ABSOLUTE);
DeviceIntPtr cp = inputInfo.pointer;
int x = 0, y = 0;
/* Sanity checks. */
if (type != MotionNotify && type != ButtonPress && type != ButtonRelease)
return 0;
if ((type == ButtonPress || type == ButtonRelease) && !pDev->button)
return 0;
if (pDev->coreEvents)
num_events = 2;
else
num_events = 1;
/* Do we need to send a DeviceValuator event? */
if ((num_valuators + first_valuator) > 2 && sendValuators) {
if ((((num_valuators - 1) / 6) + 1) > MAX_VALUATOR_EVENTS)
num_valuators = MAX_VALUATOR_EVENTS * 6;
num_events += ((num_valuators - 1) / 6) + 1;
}
else if (type == MotionNotify && num_valuators <= 0) {
return 0;
}
final_valuator = num_valuators + first_valuator;
/* You fail. */
if (first_valuator < 0 || final_valuator > pDev->valuator->numAxes)
return 0;
ms = GetTimeInMillis();
kbp = (deviceKeyButtonPointer *) events;
kbp->time = ms;
kbp->deviceid = pDev->id;
if (flags & POINTER_ABSOLUTE) {
if (num_valuators >= 1 && first_valuator == 0) {
x = valuators[0];
}
else {
if (pDev->coreEvents)
x = cp->valuator->lastx;
else
x = pDev->valuator->lastx;
}
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) {
y = valuators[1 - first_valuator];
}
else {
if (pDev->coreEvents)
x = cp->valuator->lasty;
else
y = pDev->valuator->lasty;
}
}
else {
if (flags & POINTER_ACCELERATE)
acceleratePointer(pDev, first_valuator, num_valuators,
valuators);
if (pDev->coreEvents) {
if (first_valuator == 0 && num_valuators >= 1)
x = cp->valuator->lastx + valuators[0];
else
x = cp->valuator->lastx;
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
y = cp->valuator->lasty + valuators[1 - first_valuator];
else
y = cp->valuator->lasty;
}
else {
if (first_valuator == 0 && num_valuators >= 1)
x = pDev->valuator->lastx + valuators[0];
else
x = pDev->valuator->lastx;
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
y = pDev->valuator->lasty + valuators[1 - first_valuator];
else
y = pDev->valuator->lasty;
}
}
/* Clip both x and y to the defined limits (usually co-ord space limit). */
clipAxis(pDev, 0, &x);
clipAxis(pDev, 1, &y);
/* This takes care of crossing screens for us, as well as clipping
* to the current screen. Right now, we only have one history buffer,
* so we don't set this for both the device and core.*/
miPointerSetPosition(pDev, &x, &y, ms);
/* Drop x and y back into the valuators list, if they were originally
* present. */
if (first_valuator == 0 && num_valuators >= 1)
valuators[0] = x;
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator))
valuators[1 - first_valuator] = y;
updateMotionHistory(pDev, ms, first_valuator, num_valuators, valuators);
if (pDev->coreEvents) {
cp->valuator->lastx = x;
cp->valuator->lasty = y;
}
pDev->valuator->lastx = x;
pDev->valuator->lasty = y;
if (type == MotionNotify) {
kbp->type = DeviceMotionNotify;
}
else {
if (type == ButtonPress)
kbp->type = DeviceButtonPress;
else if (type == ButtonRelease)
kbp->type = DeviceButtonRelease;
kbp->detail = pDev->button->map[buttons];
}
kbp->root_x = x;
kbp->root_y = y;
events++;
if (final_valuator > 2 && sendValuators) {
kbp->deviceid |= MORE_EVENTS;
clipValuators(pDev, first_valuator, num_valuators, valuators);
events = getValuatorEvents(events, pDev, first_valuator,
num_valuators, valuators);
}
if (pDev->coreEvents) {
events->u.u.type = type;
events->u.keyButtonPointer.time = ms;
events->u.keyButtonPointer.rootX = x;
events->u.keyButtonPointer.rootY = y;
if (type == ButtonPress || type == ButtonRelease) {
/* We hijack SetPointerMapping to work on all core-sending
* devices, so we use the device-specific map here instead of
* the core one. */
events->u.u.detail = pDev->button->map[buttons];
}
else {
events->u.u.detail = 0;
}
}
return num_events;
}
/**
* Post ProximityIn/ProximityOut events, accompanied by valuators.
*
* events is not NULL-terminated; the return value is the number of events.
* The DDX is responsible for allocating the event structure in the first
* place via GetMaximumEventsNum(), and for freeing it.
*/
_X_EXPORT int
GetProximityEvents(xEvent *events, DeviceIntPtr pDev, int type,
int first_valuator, int num_valuators, int *valuators)
{
int num_events = 0;
deviceKeyButtonPointer *kbp = (deviceKeyButtonPointer *) events;
/* Sanity checks. */
if (type != ProximityIn && type != ProximityOut)
return 0;
if (!pDev->valuator)
return 0;
/* Do we need to send a DeviceValuator event? */
if ((pDev->valuator->mode & 1) == Relative)
num_valuators = 0;
if (num_valuators) {
if ((((num_valuators - 1) / 6) + 1) > MAX_VALUATOR_EVENTS)
num_valuators = MAX_VALUATOR_EVENTS * 6;
num_events += ((num_valuators - 1) / 6) + 1;
}
/* You fail. */
if (first_valuator < 0 ||
(num_valuators + first_valuator) > pDev->valuator->numAxes)
return 0;
kbp->type = type;
kbp->deviceid = pDev->id;
kbp->detail = 0;
kbp->time = GetTimeInMillis();
if (num_valuators) {
kbp->deviceid |= MORE_EVENTS;
events++;
events = getValuatorEvents(events, pDev, first_valuator,
num_valuators, valuators);
}
return num_events;
}
/**
* Note that pDev was the last device to send a core event. This function
* copies the complete keymap from the originating device to the core
* device, and makes sure the appropriate notifications are generated.
*
* Call this just before processInputProc.
*/
_X_EXPORT void
SwitchCoreKeyboard(DeviceIntPtr pDev)
{
KeyClassPtr ckeyc = inputInfo.keyboard->key;
if (inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr != pDev) {
memcpy(ckeyc->modifierMap, pDev->key->modifierMap, MAP_LENGTH);
if (ckeyc->modifierKeyMap)
xfree(ckeyc->modifierKeyMap);
ckeyc->modifierKeyMap = xalloc(8 * pDev->key->maxKeysPerModifier);
memcpy(ckeyc->modifierKeyMap, pDev->key->modifierKeyMap,
(8 * pDev->key->maxKeysPerModifier));
ckeyc->maxKeysPerModifier = pDev->key->maxKeysPerModifier;
ckeyc->curKeySyms.minKeyCode = pDev->key->curKeySyms.minKeyCode;
ckeyc->curKeySyms.maxKeyCode = pDev->key->curKeySyms.maxKeyCode;
SetKeySymsMap(&ckeyc->curKeySyms, &pDev->key->curKeySyms);
#ifdef XKB
if (!noXkbExtension && pDev->key->xkbInfo && pDev->key->xkbInfo->desc) {
if (!XkbCopyKeymap(pDev->key->xkbInfo->desc, ckeyc->xkbInfo->desc,
True))
FatalError("Couldn't pivot keymap from device to core!\n");
}
#endif
SendMappingNotify(MappingKeyboard, ckeyc->curKeySyms.minKeyCode,
(ckeyc->curKeySyms.maxKeyCode -
ckeyc->curKeySyms.minKeyCode),
serverClient);
inputInfo.keyboard->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
}
}
/**
* Note that pDev was the last function to send a core pointer event.
* Currently a no-op.
*
* Call this just before processInputProc.
*/
_X_EXPORT void
SwitchCorePointer(DeviceIntPtr pDev)
{
if (inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr != pDev)
inputInfo.pointer->devPrivates[CoreDevicePrivatesIndex].ptr = pDev;
}
/**
* Synthesize a single motion event for the core pointer.
*
* Used in cursor functions, e.g. when cursor confinement changes, and we need
* to shift the pointer to get it inside the new bounds.
*/
void
PostSyntheticMotion(int x, int y, int screenNum, unsigned long time)
{
xEvent xE;
#ifdef PANORAMIX
/* Translate back to the sprite screen since processInputProc
will translate from sprite screen to screen 0 upon reentry
to the DIX layer. */
if (!noPanoramiXExtension) {
x += panoramiXdataPtr[0].x - panoramiXdataPtr[screenNum].x;
y += panoramiXdataPtr[0].y - panoramiXdataPtr[screenNum].y;
}
#endif
memset(&xE, 0, sizeof(xEvent));
xE.u.u.type = MotionNotify;
xE.u.keyButtonPointer.rootX = x;
xE.u.keyButtonPointer.rootY = y;
(*inputInfo.pointer->public.processInputProc)(&xE, inputInfo.pointer, 1);
}

23
dix/main.c
View File

@ -98,6 +98,7 @@ Equipment Corporation.
#include <X11/fonts/font.h>
#include "opaque.h"
#include "servermd.h"
#include "config.h"
#include "site.h"
#include "dixfont.h"
#include "extnsionst.h"
@ -248,6 +249,7 @@ main(int argc, char *argv[], char *envp[])
int i, j, k, error;
char *xauthfile;
HWEventQueueType alwaysCheckForInput[2];
CursorMetricRec cm;
display = "0";
@ -308,6 +310,7 @@ main(int argc, char *argv[], char *envp[])
DPMSPowerLevel = 0;
#endif
InitBlockAndWakeupHandlers();
configInitialise();
/* Perform any operating system dependent initializations you'd like */
OsInit();
if(serverGeneration == 1)
@ -394,23 +397,40 @@ main(int argc, char *argv[], char *envp[])
if (!CreateRootWindow(pScreen))
FatalError("failed to create root window");
}
InitCoreDevices();
InitInput(argc, argv);
if (InitAndStartDevices() != Success)
FatalError("failed to initialize core devices");
InitFonts();
#ifdef BUILTIN_FONTS
defaultFontPath = "built-ins";
#else
if (loadableFonts) {
SetFontPath(0, 0, (unsigned char *)defaultFontPath, &error);
} else {
} else
#endif
{
if (SetDefaultFontPath(defaultFontPath) != Success)
ErrorF("failed to set default font path '%s'",
defaultFontPath);
}
if (!SetDefaultFont(defaultTextFont))
FatalError("could not open default font '%s'", defaultTextFont);
#ifdef NULL_ROOT_CURSOR
cm.width = 0;
cm.height = 0;
cm.xhot = 0;
cm.yhot = 0;
if (!(rootCursor = AllocCursor(NULL, NULL, &cm, 0, 0, 0, 0, 0, 0)))
FatalError("could not create empty root cursor");
AddResource(FakeClientID(0), RT_CURSOR, (pointer)rootCursor);
#else
if (!(rootCursor = CreateRootCursor(defaultCursorFont, 0)))
FatalError("could not open default cursor font '%s'",
defaultCursorFont);
#endif
#ifdef DPMSExtension
/* check all screens, looking for DPMS Capabilities */
DPMSCapableFlag = DPMSSupported();
@ -461,6 +481,7 @@ main(int argc, char *argv[], char *envp[])
FreeAllResources();
#endif
configFini();
CloseDownDevices();
for (i = screenInfo.numScreens - 1; i >= 0; i--)
{

32
doc/c-extensions Normal file
View File

@ -0,0 +1,32 @@
Use of extensions throughout the X server tree
----------------------------------------------
Optional extensions:
The server will still build if your toolchain does not support these
extensions, although the results may not be optimal.
* _X_SENTINEL(x): member x of the passed structure must be NULL, e.g.:
void parseOptions(Option *options _X_SENTINEL(0));
parseOptions("foo", "bar", NULL); /* this is OK */
parseOptions("foo", "bar", "baz"); /* this is not */
This definition comes from Xfuncproto.h in the core
protocol headers.
* _X_ATTRIBUTE_PRINTF(x, y): This function has printf-like semantics;
check the format string when built with
-Wformat (gcc) or similar.
* _X_EXPORT: this function should appear in symbol tables.
* _X_HIDDEN: this function should not appear in the _dynamic_ symbol
table.
* _X_INTERNAL: like _X_HIDDEN, but attempt to ensure that this function
is never called from another module.
* _X_INLINE: inline this functon if possible (generally obeyed unless
disabling optimisations).
* _X_DEPRECATED: warn on use of this function.
Mandatory extensions:
The server will not build if your toolchain does not support these extensions.
* named initialisers: explicitly initialising structure members, e.g.:
struct foo bar = { .baz = quux, .brian = "dog" };
* variadic macros: macros with a variable number of arguments, e.g.:
#define DebugF(x, ...) /**/

15
fb/fbpict.c
View File

@ -930,9 +930,8 @@ fbComposite (CARD8 op,
case PictOpOver:
if (pMask)
{
if (srcRepeat &&
pSrc->pDrawable->width == 1 &&
pSrc->pDrawable->height == 1)
if (fbCanGetSolid(pSrc) &&
!maskRepeat)
{
srcRepeat = FALSE;
if (PICT_FORMAT_COLOR(pSrc->format)) {
@ -1044,7 +1043,7 @@ fbComposite (CARD8 op,
{
if (pSrc->pDrawable == pMask->pDrawable &&
xSrc == xMask && ySrc == yMask &&
!pMask->componentAlpha)
!pMask->componentAlpha && !maskRepeat)
{
/* source == mask: non-premultiplied data */
switch (pSrc->format) {
@ -1108,9 +1107,7 @@ fbComposite (CARD8 op,
else
{
/* non-repeating source, repeating mask => translucent window */
if (maskRepeat &&
pMask->pDrawable->width == 1 &&
pMask->pDrawable->height == 1)
if (fbCanGetSolid(pMask))
{
if (pSrc->format == PICT_x8r8g8b8 &&
pDst->format == PICT_x8r8g8b8 &&
@ -1127,9 +1124,7 @@ fbComposite (CARD8 op,
}
else /* no mask */
{
if (srcRepeat &&
pSrc->pDrawable->width == 1 &&
pSrc->pDrawable->height == 1)
if (fbCanGetSolid(pSrc))
{
/* no mask and repeating source */
switch (pSrc->format) {

47
fb/fbpict.h
View File

@ -30,6 +30,13 @@
#include "renderedge.h"
#if defined(__GNUC__)
#define INLINE __inline__
#else
#define INLINE
#endif
#define FbIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )
#define FbIntDiv(a,b) (((CARD16) (a) * 255) / (b))
@ -67,6 +74,40 @@
#define Green(x) (((x) >> 8) & 0xff)
#define Blue(x) ((x) & 0xff)
/**
* Returns TRUE if the fbComposeGetSolid can be used to get a single solid
* color representing every source sampling location of the picture.
*/
static INLINE Bool
fbCanGetSolid(PicturePtr pict)
{
if (pict->pDrawable == NULL ||
pict->pDrawable->width != 1 ||
pict->pDrawable->height != 1)
{
return FALSE;
}
if (pict->repeat != RepeatNormal)
return FALSE;
switch (pict->format) {
case PICT_a8r8g8b8:
case PICT_x8r8g8b8:
case PICT_a8b8g8r8:
case PICT_x8b8g8r8:
case PICT_r8g8b8:
case PICT_b8g8r8:
case PICT_r5g6b5:
case PICT_b5g6r5:
return TRUE;
default:
return FALSE;
}
}
#define fbCanGetSolid(pict) \
(pict->pDrawable != NULL && pict->pDrawable->width == 1 && pict->pDrawable->height == 1)
#define fbComposeGetSolid(pict, bits, fmt) { \
FbBits *__bits__; \
FbStride __stride__; \
@ -322,12 +363,6 @@
#define FASTCALL
#endif
#if defined(__GNUC__)
#define INLINE __inline__
#else
#define INLINE
#endif
typedef struct _FbComposeData {
CARD8 op;
PicturePtr src;

2
hw/darwin/darwinKeyboard.c
View File

@ -1020,7 +1020,7 @@ int DarwinModifierStringToNXKey(const char *str)
* This allows the ddx layer to prevent some keys from being remapped
* as modifier keys.
*/
Bool LegalModifier(unsigned int key, DevicePtr pDev)
Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
{
return 1;
}

2
hw/dmx/dmxinput.c
View File

@ -53,7 +53,7 @@
/** Returns TRUE if the key is a valid modifier. For PC-class
* keyboards, all keys can be used as modifiers, so return TRUE
* always. */
Bool LegalModifier(unsigned int key, DevicePtr pDev)
Bool LegalModifier(unsigned int key, DeviceIntPtr pDev)
{
return TRUE;
}

8
hw/kdrive/Makefile.am
View File

@ -3,10 +3,14 @@ VESA_SUBDIRS = vesa ati chips epson i810 mach64 mga neomagic nvidia pm2 r128 \
smi via
endif
if KDRIVEFBDEV
if BUILD_KDRIVEFBDEVLIB
FBDEV_SUBDIRS = fbdev
endif
if XFAKESERVER
XFAKE_SUBDIRS = fake
endif
if XSDLSERVER
XSDL_SUBDIRS = sdl
endif
@ -22,7 +26,7 @@ SUBDIRS = \
$(FBDEV_SUBDIRS) \
$(VESA_SUBDIRS) \
$(XEPHYR_SUBDIRS) \
fake
$(XFAKE_SUBDIRS)
DIST_SUBDIRS = vesa ati chips epson i810 mach64 mga neomagic nvidia pm2 r128 \
smi via fbdev sdl ephyr src linux fake sis300

10
hw/kdrive/ati/Makefile.am
View File

@ -61,12 +61,4 @@ ATI_LIBS = \
Xati_LDADD = \
$(ATI_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xati_DEPENDENCIES = \
libati.a \
$(FBDEV_LIBS) \
$(VESA_LIBS) \
$(DRI_LIBS)
@XSERVER_LIBS@

10
hw/kdrive/ati/ati_stub.c
View File

@ -53,7 +53,15 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput(int argc, char **argv)
{
KdInitInput(&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdKeyboardInfo *ki = NULL;
KdAddPointerDriver(&LinuxMouseDriver);
ki = KdNewKeyboard();
if (ki) {
ki->driver = &LinuxKeyboardDriver;
KdAddKeyboard(ki);
}
KdInitInput();
}
void

4
hw/kdrive/chips/Makefile.am
View File

@ -24,7 +24,3 @@ Xchips_LDADD = \
$(CHIPS_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xchips_DEPENDENCIES = \
libchips.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

3
hw/kdrive/chips/chipsstub.c
View File

@ -48,7 +48,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

5
hw/kdrive/ephyr/Makefile.am
View File

@ -28,9 +28,4 @@ Xephyr_LDADD = \
libxephyr-hostx.a \
../../../exa/libexa.la \
@KDRIVE_LIBS@ \
@KDRIVE_LIBS@ \
@XEPHYR_LIBS@
Xephyr_DEPENDENCIES = \
libxephyr.a \
libxephyr-hostx.a

153
hw/kdrive/ephyr/ephyr.c
View File

@ -36,10 +36,16 @@
#include "inputstr.h"
extern int KdTsPhyScreen;
extern DeviceIntPtr pKdKeyboard;
KdKeyboardInfo *ephyrKbd;
KdPointerInfo *ephyrMouse;
EphyrKeySyms ephyrKeySyms;
static int mouseState = 0;
typedef struct _EphyrInputPrivate {
Bool enabled;
} EphyrKbdPrivate, EphyrPointerPrivate;
Bool EphyrWantGrayScale = 0;
Bool
@ -206,15 +212,14 @@ ephyrMapFramebuffer (KdScreenInfo *screen)
{
EphyrScrPriv *scrpriv = screen->driver;
EphyrPriv *priv = screen->card->driver;
KdMouseMatrix m;
KdPointerMatrix m;
int buffer_height;
EPHYR_DBG(" screen->width: %d, screen->height: %d",
screen->width, screen->height);
KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdSetMouseMatrix (&m);
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdSetPointerMatrix (&m);
priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
@ -719,8 +724,9 @@ ephyrUpdateModifierState(unsigned int state)
kptr = &keyc->down[key >> 3];
bit = 1 << (key & 7);
if (*kptr & bit)
KdEnqueueKeyboardEvent(key, TRUE); /* release */
if (*kptr & bit && ephyrKbd &&
((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
KdEnqueueKeyboardEvent(ephyrKbd, key, TRUE); /* release */
if (--count == 0)
break;
@ -732,7 +738,9 @@ ephyrUpdateModifierState(unsigned int state)
for (key = 0; key < MAP_LENGTH; key++)
if (keyc->modifierMap[key] & mask)
{
KdEnqueueKeyboardEvent(key, FALSE); /* press */
if (keyc->modifierMap[key] & mask && ephyrKbd &&
((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
KdEnqueueKeyboardEvent(ephyrKbd, key, FALSE); /* press */
break;
}
}
@ -748,31 +756,47 @@ ephyrPoll(void)
switch (ev.type)
{
case EPHYR_EV_MOUSE_MOTION:
KdEnqueueMouseEvent(kdMouseInfo, mouseState,
ev.data.mouse_motion.x,
ev.data.mouse_motion.y);
if (!ephyrMouse ||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
continue;
KdEnqueuePointerEvent(ephyrMouse, mouseState,
ev.data.mouse_motion.x,
ev.data.mouse_motion.y,
0);
break;
case EPHYR_EV_MOUSE_PRESS:
if (!ephyrMouse ||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
continue;
ephyrUpdateModifierState(ev.key_state);
mouseState |= ev.data.mouse_down.button_num;
KdEnqueueMouseEvent(kdMouseInfo, mouseState|KD_MOUSE_DELTA, 0, 0);
KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
break;
case EPHYR_EV_MOUSE_RELEASE:
if (!ephyrMouse ||
!((EphyrPointerPrivate *)ephyrMouse->driverPrivate)->enabled)
continue;
ephyrUpdateModifierState(ev.key_state);
mouseState &= ~ev.data.mouse_up.button_num;
KdEnqueueMouseEvent(kdMouseInfo, mouseState|KD_MOUSE_DELTA, 0, 0);
KdEnqueuePointerEvent(ephyrMouse, mouseState|KD_MOUSE_DELTA, 0, 0, 0);
break;
case EPHYR_EV_KEY_PRESS:
if (!ephyrKbd ||
!((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
continue;
ephyrUpdateModifierState(ev.key_state);
KdEnqueueKeyboardEvent (ev.data.key_down.scancode, FALSE);
KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_down.scancode, FALSE);
break;
case EPHYR_EV_KEY_RELEASE:
if (!ephyrKbd ||
!((EphyrKbdPrivate *)ephyrKbd->driverPrivate)->enabled)
continue;
ephyrUpdateModifierState(ev.key_state);
KdEnqueueKeyboardEvent (ev.data.key_up.scancode, TRUE);
KdEnqueueKeyboardEvent (ephyrKbd, ev.data.key_up.scancode, TRUE);
break;
default:
@ -833,59 +857,112 @@ ephyrPutColors (ScreenPtr pScreen, int fb, int n, xColorItem *pdefs)
/* Mouse calls */
static Bool
MouseInit (void)
static Status
MouseInit (KdPointerInfo *pi)
{
return TRUE;
pi->driverPrivate = (EphyrPointerPrivate *)
xcalloc(sizeof(EphyrPointerPrivate), 1);
((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
pi->nAxes = 3;
pi->nButtons = 32;
pi->name = KdSaveString("Xephyr virtual mouse");
ephyrMouse = pi;
return Success;
}
static Status
MouseEnable (KdPointerInfo *pi)
{
((EphyrPointerPrivate *)pi->driverPrivate)->enabled = TRUE;
return Success;
}
static void
MouseFini (void)
MouseDisable (KdPointerInfo *pi)
{
;
((EphyrPointerPrivate *)pi->driverPrivate)->enabled = FALSE;
return;
}
KdMouseFuncs EphyrMouseFuncs = {
static void
MouseFini (KdPointerInfo *pi)
{
ephyrMouse = NULL;
return;
}
KdPointerDriver EphyrMouseDriver = {
"ephyr",
MouseInit,
MouseEnable,
MouseDisable,
MouseFini,
NULL,
};
/* Keyboard */
static void
EphyrKeyboardLoad (void)
static Status
EphyrKeyboardInit (KdKeyboardInfo *ki)
{
EPHYR_DBG("mark");
ki->driverPrivate = (EphyrKbdPrivate *)
xcalloc(sizeof(EphyrKbdPrivate), 1);
hostx_load_keymap();
if (!ephyrKeySyms.map) {
ErrorF("Couldn't load keymap from host\n");
return BadAlloc;
}
ki->keySyms.minKeyCode = ephyrKeySyms.minKeyCode;
ki->keySyms.maxKeyCode = ephyrKeySyms.maxKeyCode;
ki->minScanCode = ki->keySyms.minKeyCode;
ki->maxScanCode = ki->keySyms.maxKeyCode;
ki->keySyms.mapWidth = ephyrKeySyms.mapWidth;
ki->keySyms.map = ephyrKeySyms.map;
ki->name = KdSaveString("Xephyr virtual keyboard");
ephyrKbd = ki;
return Success;
}
static int
EphyrKeyboardInit (void)
static Status
EphyrKeyboardEnable (KdKeyboardInfo *ki)
{
return 0;
((EphyrKbdPrivate *)ki->driverPrivate)->enabled = TRUE;
return Success;
}
static void
EphyrKeyboardFini (void)
EphyrKeyboardDisable (KdKeyboardInfo *ki)
{
((EphyrKbdPrivate *)ki->driverPrivate)->enabled = FALSE;
}
static void
EphyrKeyboardFini (KdKeyboardInfo *ki)
{
/* not xfree: we call malloc from hostx.c. */
free(ki->keySyms.map);
ephyrKbd = NULL;
return;
}
static void
EphyrKeyboardLeds (KdKeyboardInfo *ki, int leds)
{
}
static void
EphyrKeyboardLeds (int leds)
EphyrKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
{
}
static void
EphyrKeyboardBell (int volume, int frequency, int duration)
{
}
KdKeyboardFuncs EphyrKeyboardFuncs = {
EphyrKeyboardLoad,
KdKeyboardDriver EphyrKeyboardDriver = {
"ephyr",
EphyrKeyboardInit,
EphyrKeyboardEnable,
EphyrKeyboardLeds,
EphyrKeyboardBell,
EphyrKeyboardDisable,
EphyrKeyboardFini,
0,
NULL,
};

9
hw/kdrive/ephyr/ephyr.h
View File

@ -31,7 +31,6 @@
#include "os.h" /* for OsSignal() */
#include "kdrive.h"
#include "kkeymap.h"
#include "hostx.h"
#include "exa.h"
@ -68,7 +67,9 @@ typedef struct _ephyrScrPriv {
EphyrFakexaPriv *fakexa;
} EphyrScrPriv;
extern KdCardFuncs ephyrFuncs;
extern KdCardFuncs ephyrFuncs;
extern KdKeyboardInfo *ephyrKbd;
extern KdPointerInfo *ephyrMouse;
Bool
ephyrInitialize (KdCardInfo *card, EphyrPriv *priv);
@ -167,9 +168,9 @@ ephyrShadowUpdate (ScreenPtr pScreen, shadowBufPtr pBuf);
void
ephyrUpdateModifierState(unsigned int state);
extern KdMouseFuncs EphyrMouseFuncs;
extern KdPointerDriver EphyrMouseDriver;
extern KdKeyboardFuncs EphyrKeyboardFuncs;
extern KdKeyboardDriver EphyrKeyboardDriver;
extern KdOsFuncs EphyrOsFuncs;

19
hw/kdrive/ephyr/ephyrinit.c
View File

@ -51,7 +51,24 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&EphyrMouseFuncs, &EphyrKeyboardFuncs);
KdKeyboardInfo *ki;
KdPointerInfo *pi;
ki = KdNewKeyboard();
if (!ki)
FatalError("Couldn't create Xephyr keyboard\n");
ki->driver = &EphyrKeyboardDriver;
KdAddKeyboardDriver(&EphyrKeyboardDriver);
KdAddKeyboard(ki);
pi = KdNewPointer();
if (!pi)
FatalError("Couldn't create Xephyr pointer\n");
pi->driver = &EphyrMouseDriver;
KdAddPointerDriver(&EphyrMouseDriver);
KdAddPointer(pi);
KdInitInput();
}
void

32
hw/kdrive/ephyr/hostx.c
View File

@ -77,14 +77,8 @@ static EphyrHostXVars HostX = { "?", 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
static int HostXWantDamageDebug = 0;
extern KeySym EphyrKeymap[];
extern EphyrKeySyms ephyrKeySyms;
extern KeySym kdKeymap[];
extern int kdMinScanCode;
extern int kdMaxScanCode;
extern int kdMinKeyCode;
extern int kdMaxKeyCode;
extern int kdKeymapWidth;
extern int monitorResolution;
static void
@ -403,9 +397,9 @@ hostx_get_bpp(void)
}
void
hostx_get_visual_masks (unsigned long *rmsk,
unsigned long *gmsk,
unsigned long *bmsk)
hostx_get_visual_masks (CARD32 *rmsk,
CARD32 *gmsk,
CARD32 *bmsk)
{
if (host_depth_matches_server())
{
@ -683,19 +677,21 @@ hostx_load_keymap(void)
*/
width = (host_width > 4) ? 4 : host_width;
ephyrKeySyms.map = (KeySym *)calloc(sizeof(KeySym),
(max_keycode - min_keycode + 1) *
width);
if (!ephyrKeySyms.map)
return;
for (i=0; i<(max_keycode - min_keycode+1); i++)
for (j=0; j<width; j++)
kdKeymap[ (i*width)+j ] = keymap[ (i*host_width) + j ];
ephyrKeySyms.map[(i*width)+j] = keymap[(i*host_width) + j];
EPHYR_DBG("keymap width, host:%d kdrive:%d", host_width, width);
/* all kdrive vars - see kkeymap.c */
kdMinScanCode = min_keycode;
kdMaxScanCode = max_keycode;
kdMinKeyCode = min_keycode;
kdMaxKeyCode = max_keycode;
kdKeymapWidth = width;
ephyrKeySyms.minKeyCode = min_keycode;
ephyrKeySyms.maxKeyCode = max_keycode;
ephyrKeySyms.mapWidth = width;
XFree(keymap);
}

17
hw/kdrive/ephyr/hostx.h
View File

@ -26,6 +26,9 @@
#ifndef _XLIBS_STUFF_H_
#define _XLIBS_STUFF_H_
#include <X11/X.h>
#include <X11/Xmd.h>
#define EPHYR_WANT_DEBUG 0
#if (EPHYR_WANT_DEBUG)
@ -48,6 +51,14 @@ typedef enum EphyrHostXEventType
}
EphyrHostXEventType;
/* I can't believe it's not a KeySymsRec. */
typedef struct {
int minKeyCode;
int maxKeyCode;
int mapWidth;
KeySym *map;
} EphyrKeySyms;
struct EphyrHostXEvent
{
EphyrHostXEventType type;
@ -126,9 +137,9 @@ int
hostx_get_bpp(void);
void
hostx_get_visual_masks (unsigned long *rmsk,
unsigned long *gmsk,
unsigned long *bmsk);
hostx_get_visual_masks (CARD32 *rmsk,
CARD32 *gmsk,
CARD32 *bmsk);
void
hostx_set_cmap_entry(unsigned char idx,
unsigned char r,

30
hw/kdrive/ephyr/os.c
View File

@ -34,34 +34,8 @@ EphyrInit (void)
return hostx_init();
}
static void
EphyrEnable (void)
{
EPHYR_DBG("mark");
}
static Bool
EphyrSpecialKey (KeySym sym)
{
return FALSE;
}
static void
EphyrDisable (void)
{
}
static void
EphyrFini (void)
{
}
KdOsFuncs EphyrOsFuncs = {
EphyrInit,
EphyrEnable,
EphyrSpecialKey,
EphyrDisable,
EphyrFini,
ephyrPoll
.Init = EphyrInit,
.pollEvents = ephyrPoll,
};

2
hw/kdrive/epson/Makefile.am
View File

@ -24,5 +24,3 @@ Xepson_LDADD = \
$(EPSON_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xepson_DEPENDENCIES = libepson.a

6
hw/kdrive/epson/epson13806stub.c
View File

@ -53,10 +53,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
#ifdef TOUCHSCREEN
KdAddMouseDriver (&TsFuncs);
#endif
KdOsAddInputDrivers ();
KdInitInput ();
}
int

9
hw/kdrive/fake/Makefile.am
View File

@ -6,10 +6,6 @@ noinst_LIBRARIES = libfake.a
bin_PROGRAMS = Xfake
if TSLIB
TSLIB_FLAG = -lts
endif
libfake_a_SOURCES = \
fake.c \
kbd.c \
@ -23,9 +19,4 @@ Xfake_SOURCES = \
Xfake_LDADD = \
libfake.a \
@KDRIVE_LIBS@ \
@KDRIVE_LIBS@ \
$(TSLIB_FLAG) \
@XSERVER_LIBS@
Xfake_DEPENDENCIES = \
libfake.a

6
hw/kdrive/fake/fake.c
View File

@ -158,7 +158,7 @@ Bool
fakeMapFramebuffer (KdScreenInfo *screen)
{
FakeScrPriv *scrpriv = screen->driver;
KdMouseMatrix m;
KdPointerMatrix m;
FakePriv *priv = screen->card->driver;
if (scrpriv->randr != RR_Rotate_0)
@ -166,9 +166,9 @@ fakeMapFramebuffer (KdScreenInfo *screen)
else
scrpriv->shadow = FALSE;
KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdSetMouseMatrix (&m);
KdSetPointerMatrix (&m);
priv->bytes_per_line = ((screen->width * screen->fb[0].bitsPerPixel + 31) >> 5) << 2;
if (priv->base)

4
hw/kdrive/fake/fake.h
View File

@ -130,9 +130,9 @@ fakeRandRInit (ScreenPtr pScreen);
#endif
extern KdMouseFuncs FakeMouseFuncs;
extern KdPointerDriver FakePointerDriver;
extern KdKeyboardFuncs FakeKeyboardFuncs;
extern KdKeyboardDriver FakeKeyboardDriver;
extern KdOsFuncs FakeOsFuncs;

17
hw/kdrive/fake/fakeinit.c
View File

@ -44,7 +44,22 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&FakeMouseFuncs, &FakeKeyboardFuncs);
KdPointerInfo *pi;
KdKeyboardInfo *ki;
pi = KdNewPointer ();
if (!pi)
return;
pi->driver = &FakePointerDriver;
KdAddPointer(pi);
ki = KdNewKeyboard ();
if (!ki)
return;
ki->driver = &FakeKeyboardDriver;
KdAddKeyboard(ki);
KdInitInput ();
}
void

56
hw/kdrive/fake/kbd.c
View File

@ -27,7 +27,6 @@
#include <kdrive-config.h>
#endif
#include "fake.h"
#include "kkeymap.h"
#include <X11/keysym.h>
#define FAKE_WIDTH 2
@ -155,41 +154,58 @@ KeySym FakeKeymap[] = {
/* 116 123 */ NoSymbol, NoSymbol, /* tiny button */
};
static void
FakeKeyboardLoad (void)
static Status
FakeKeyboardInit (KdKeyboardInfo *ki)
{
kdMinScanCode = 1;
kdKeymapWidth = FAKE_WIDTH;
kdMaxScanCode = (sizeof (FakeKeymap) / sizeof (FakeKeymap[0])) / FAKE_WIDTH;
memcpy (kdKeymap, FakeKeymap, sizeof (FakeKeymap));
ki->keySyms.minKeyCode = 1;
ki->keySyms.maxKeyCode = (sizeof (FakeKeymap) / sizeof (FakeKeymap[0])) / FAKE_WIDTH;
ki->keySyms.mapWidth = FAKE_WIDTH;
if (ki->keySyms.map)
xfree(ki->keySyms.map);
ki->keySyms.map = (KeySym *)xalloc(sizeof(FakeKeymap));
if (!ki->keySyms.map)
return BadAlloc;
memcpy (ki->keySyms.map, FakeKeymap, sizeof (FakeKeymap));
return Success;
}
static int
FakeKeyboardInit (void)
static Status
FakeKeyboardEnable (KdKeyboardInfo *ki)
{
return 0;
return Success;
}
static void
FakeKeyboardFini (void)
FakeKeyboardDisable (KdKeyboardInfo *ki)
{
return;
}
static void
FakeKeyboardFini (KdKeyboardInfo *ki)
{
xfree(ki->keySyms.map);
ki->keySyms.map = NULL;
}
static void
FakeKeyboardLeds (KdKeyboardInfo *ki, int leds)
{
}
static void
FakeKeyboardLeds (int leds)
FakeKeyboardBell (KdKeyboardInfo *ki, int volume, int frequency, int duration)
{
}
static void
FakeKeyboardBell (int volume, int frequency, int duration)
{
}
KdKeyboardFuncs FakeKeyboardFuncs = {
FakeKeyboardLoad,
KdKeyboardDriver FakeKeyboardDriver = {
"fake",
FakeKeyboardInit,
FakeKeyboardEnable,
FakeKeyboardLeds,
FakeKeyboardBell,
FakeKeyboardDisable,
FakeKeyboardFini,
0,
NULL,
};

26
hw/kdrive/fake/mouse.c
View File

@ -35,19 +35,35 @@
#include "scrnintstr.h"
#include "kdrive.h"
static Bool
MouseInit (void)
static Status
MouseInit (KdPointerInfo *pi)
{
return TRUE;
return Success;
}
static Status
MouseEnable (KdPointerInfo *pi)
{
return Success;
}
static void
MouseFini (void)
MouseDisable (KdPointerInfo *pi)
{
return;
}
static void
MouseFini (KdPointerInfo *pi)
{
return;
}
KdMouseFuncs FakeMouseFuncs = {
KdPointerDriver FakePointerDriver = {
"fake",
MouseInit,
MouseEnable,
MouseDisable,
MouseFini,
};

11
hw/kdrive/fbdev/Makefile.am
View File

@ -4,19 +4,18 @@ INCLUDES = \
noinst_LIBRARIES = libfbdev.a
bin_PROGRAMS = Xfbdev
libfbdev_a_SOURCES = \
fbdev.c \
fbdev.h
if KDRIVEFBDEV
bin_PROGRAMS = Xfbdev
Xfbdev_SOURCES = \
fbinit.c
Xfbdev_LDADD = \
libfbdev.a \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xfbdev_DEPENDENCIES = \
libfbdev.a
@XSERVER_LIBS@
endif

6
hw/kdrive/fbdev/fbdev.c
View File

@ -331,7 +331,7 @@ Bool
fbdevMapFramebuffer (KdScreenInfo *screen)
{
FbdevScrPriv *scrpriv = screen->driver;
KdMouseMatrix m;
KdPointerMatrix m;
FbdevPriv *priv = screen->card->driver;
if (scrpriv->randr != RR_Rotate_0)
@ -339,9 +339,9 @@ fbdevMapFramebuffer (KdScreenInfo *screen)
else
scrpriv->shadow = FALSE;
KdComputeMouseMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdComputePointerMatrix (&m, scrpriv->randr, screen->width, screen->height);
KdSetMouseMatrix (&m);
KdSetPointerMatrix (&m);
screen->width = priv->var.xres;
screen->height = priv->var.yres;

14
hw/kdrive/fbdev/fbinit.c
View File

@ -45,10 +45,18 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
#ifdef TOUCHSCREEN
KdAddMouseDriver (&TsFuncs);
KdKeyboardInfo *ki;
KdAddKeyboardDriver (&LinuxKeyboardDriver);
KdAddPointerDriver (&LinuxMouseDriver);
#ifdef TSLIB
KdAddPointerDriver (&TsDriver);
#endif
ki = KdParseKeyboard ("keybd");
KdAddKeyboard(ki);
KdInitInput ();
}
void

2
hw/kdrive/i810/Makefile.am
View File

@ -27,5 +27,3 @@ Xi810_LDADD = \
$(I810_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xi810_DEPENDENCIES = libi810.a

3
hw/kdrive/i810/i810stub.c
View File

@ -73,7 +73,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

3
hw/kdrive/igs/igsstub.c
View File

@ -56,7 +56,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

51
hw/kdrive/itsy/kbd.c
View File

@ -27,7 +27,6 @@
#include <kdrive-config.h>
#endif
#include "itsy.h"
#include "kkeymap.h"
#include <X11/keysym.h>
#include <linux/itsy_buttons.h>
@ -167,28 +166,44 @@ ItsyKeyboardLoad (void)
{
KeySym *k;
itsyButtonState = 0;
kdMinScanCode = 1;
kdKeymapWidth = ITSY_WIDTH;
kdMaxScanCode = (sizeof (ItsyKeymap) / sizeof (ItsyKeymap[0])) / ITSY_WIDTH;
memcpy (kdKeymap, ItsyKeymap, sizeof (ItsyKeymap));
}
int
ItsyKeyboardInit (void)
static Status
ItsyKeyboardInit (KdKeyboardInfo *ki)
{
int butPort;
if (!ki)
return BadImplementation;
butPort = open ("/dev/buttons", 0);
fprintf (stderr, "butPort %d\n", butPort);
return butPort;
ki->driverPrivate = open ("/dev/buttons", 0);
itsyButtonState = 0;
ki->keySyms.minKeyCode = 1;
ki->keySyms.maxKeyCode = (sizeof (ItsyKeymap) / sizeof (ItsyKeymap[0])) / ITSY_WIDTH;
ki->minScanCode = ki->keySyms.minKeyCode;
ki->maxScanCode = ki->keySyms.maxKeyCode;
ki->keySyms.mapWidth = ITSY_WIDTH;
if (ki->keySyms.map)
xfree(ki->keySyms.map);
ki->keySyms.map = xalloc(sizeof(ItsyKeymap));
if (!ki->keySyms.map)
return BadAlloc;
memcpy (kdKeymap, ItsyKeymap, sizeof (ItsyKeymap));
return Success;
}
void
ItsyKeyboardFini (int fd)
static void
ItsyKeyboardDisable (KdKeybdInfo *ki)
{
if (fd >= 0)
close (fd);
close ((int)ki->driverPrivate);
}
static void
ItsyKeyboardFini (KdKeybdInfo *ki)
{
return;
}
void
@ -227,11 +242,13 @@ ItsyKeyboardBell (int volume, int frequency, int duration)
}
KdKeyboardFuncs itsyKeyboardFuncs = {
ItsyKeyboardLoad,
"itsy",
ItsyKeyboardInit,
ItsyKeyboardEnable,
ItsyKeyboardRead,
ItsyKeyboardLeds,
ItsyKeyboardBell,
ItsyKeyboardDisable
ItsyKeyboardFini,
0,
NULL,
};

7
hw/kdrive/itsy/ts.c
View File

@ -63,7 +63,7 @@ itsyTsReadBytes (int fd, char *buf, int len, int min)
}
void
itsyTsRead (int tsPort)
itsyTsRead (KdPointerInfo *pi, int tsPort)
{
ts_event event;
long buf[3];
@ -89,7 +89,7 @@ itsyTsRead (int tsPort)
x = 0;
y = 0;
}
KdEnqueueMouseEvent (flags, x, y);
KdEnqueuePointerEvent (pi, flags, x, y, 0);
}
}
@ -204,7 +204,8 @@ itsyTsFini (int tsPort)
close (tsPort);
}
KdMouseFuncs itsyTsMouseFuncs = {
KdPointerDriver itsyTsMouseDriver = {
"itsyts",
itsyTsInit,
itsyTsRead,
itsyTsFini

13
hw/kdrive/linux/Makefile.am
View File

@ -32,16 +32,3 @@ liblinux_a_SOURCES = \
$(KDRIVE_HW_SOURCES) \
$(TSLIB_C) \
$(TS_C)
liblinux_a_DEPENDENCIES = \
agp.c \
bus.c \
keyboard.c \
linux.c \
mouse.c \
evdev.c \
ms.c \
ps2.c \
$(TSLIB_C) \
$(TS_C)

75
hw/kdrive/linux/bus.c
View File

@ -55,7 +55,7 @@ BusRead (int adbPort, void *closure)
flags |= KD_BUTTON_2;
if ((buf[0] & 1) == 0)
flags |= KD_BUTTON_3;
KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
}
}
@ -66,36 +66,71 @@ char *BusNames[] = {
#define NUM_BUS_NAMES (sizeof (BusNames) / sizeof (BusNames[0]))
int BusInputType;
static int
BusInit (KdPointerInfo *pi)
{
int i, fd = 0;
if (!pi->path || (strcmp(pi->path, "auto") == 0))
{
for (i = 0; i < NUM_BUS_NAMES; i++)
{
if ((fd = open (BusNames[i], 0)) > 0)
{
close(fd);
if (pi->path)
xfree(pi->path);
pi->path = KdSaveString(BusNames[i]);
return Success;
}
}
}
else
{
if ((fd = open(pi->path, 0)) > 0)
{
close(fd);
return Success;
}
}
return !Success;
}
static int
BusInit (void)
BusEnable (KdPointerInfo *pi)
{
int i;
int busPort;
int n = 0;
int fd = open(pi->path, 0);
if (!BusInputType)
BusInputType = KdAllocInputType ();
for (i = 0; i < NUM_BUS_NAMES; i++)
if (fd > 0)
{
busPort = open (BusNames[i], 0);
{
KdRegisterFd (BusInputType, busPort, BusRead, 0);
n++;
}
KdRegisterFd(fd, BusRead, pi);
pi->driverPrivate = (void *)fd;
return Success;
}
else
{
return !Success;
}
return n;
}
static void
BusFini (void)
BusDisable (KdPointerInfo *pi)
{
KdUnregisterFds (BusInputType, TRUE);
KdUnregisterFd(pi, (int)pi->driverPrivate, TRUE);
}
KdMouseFuncs BusMouseFuncs = {
static void
BusFini (KdPointerInfo *pi)
{
return;
}
KdPointerDriver BusMouseDriver = {
"bus",
BusInit,
BusFini
BusEnable,
BusDisable,
BusFini,
NULL
};

390
hw/kdrive/linux/evdev.c
View File

@ -43,98 +43,100 @@
#define ISBITSET(x,y) ((x)[LONG(y)] & BIT(y))
#define OFF(x) ((x)%BITS_PER_LONG)
#define LONG(x) ((x)/BITS_PER_LONG)
#define BIT(x) (1 << OFF(x))
#define BIT(x) (1 << OFF(x))
#define SETBIT(x,y) ((x)[LONG(y)] |= BIT(y))
#define CLRBIT(x,y) ((x)[LONG(y)] &= ~BIT(y))
#define ASSIGNBIT(x,y,z) ((x)[LONG(y)] = ((x)[LONG(y)] & ~BIT(y)) | (z << OFF(y)))
typedef struct _kevdevMouse {
/* current device state */
int rel[REL_MAX + 1];
int abs[ABS_MAX + 1];
int prevabs[ABS_MAX + 1];
long key[NBITS(KEY_MAX + 1)];
int rel[REL_MAX + 1];
int abs[ABS_MAX + 1];
int prevabs[ABS_MAX + 1];
long key[NBITS(KEY_MAX + 1)];
/* supported device info */
long relbits[NBITS(REL_MAX + 1)];
long absbits[NBITS(ABS_MAX + 1)];
long keybits[NBITS(KEY_MAX + 1)];
long relbits[NBITS(REL_MAX + 1)];
long absbits[NBITS(ABS_MAX + 1)];
long keybits[NBITS(KEY_MAX + 1)];
struct input_absinfo absinfo[ABS_MAX + 1];
int max_rel;
int max_abs;
int max_rel;
int max_abs;
int fd;
} Kevdev;
static void
EvdevMotion (KdMouseInfo *mi)
EvdevMotion (KdPointerInfo *pi)
{
Kevdev *ke = mi->driver;
int i;
Kevdev *ke = pi->driverPrivate;
int i;
for (i = 0; i <= ke->max_rel; i++)
if (ke->rel[i])
{
int a;
ErrorF ("rel");
for (a = 0; a <= ke->max_rel; a++)
{
if (ISBITSET (ke->relbits, a))
ErrorF (" %d=%d", a, ke->rel[a]);
ke->rel[a] = 0;
}
ErrorF ("\n");
break;
}
if (ke->rel[i])
{
int a;
ErrorF ("rel");
for (a = 0; a <= ke->max_rel; a++)
{
if (ISBITSET (ke->relbits, a))
ErrorF (" %d=%d", a, ke->rel[a]);
ke->rel[a] = 0;
}
ErrorF ("\n");
break;
}
for (i = 0; i < ke->max_abs; i++)
if (ke->abs[i] != ke->prevabs[i])
{
int a;
ErrorF ("abs");
for (a = 0; a <= ke->max_abs; a++)
{
if (ISBITSET (ke->absbits, a))
ErrorF (" %d=%d", a, ke->abs[a]);
ke->prevabs[a] = ke->abs[a];
}
ErrorF ("\n");
break;
}
if (ke->abs[i] != ke->prevabs[i])
{
int a;
ErrorF ("abs");
for (a = 0; a <= ke->max_abs; a++)
{
if (ISBITSET (ke->absbits, a))
ErrorF (" %d=%d", a, ke->abs[a]);
ke->prevabs[a] = ke->abs[a];
}
ErrorF ("\n");
break;
}
}
static void
EvdevRead (int evdevPort, void *closure)
{
KdMouseInfo *mi = closure;
Kevdev *ke = mi->driver;
int i;
struct input_event events[NUM_EVENTS];
int n;
KdPointerInfo *pi = closure;
Kevdev *ke = pi->driverPrivate;
int i;
struct input_event events[NUM_EVENTS];
int n;
n = read (evdevPort, &events, NUM_EVENTS * sizeof (struct input_event));
if (n <= 0)
return;
return;
n /= sizeof (struct input_event);
for (i = 0; i < n; i++)
{
switch (events[i].type) {
case EV_SYN:
break;
case EV_KEY:
EvdevMotion (mi);
ASSIGNBIT(ke->key,events[i].code, events[i].value);
if (events[i].code < 0x100)
ErrorF ("key %d %d\n", events[i].code, events[i].value);
else
ErrorF ("key 0x%x %d\n", events[i].code, events[i].value);
break;
case EV_REL:
ke->rel[events[i].code] += events[i].value;
break;
case EV_ABS:
ke->abs[events[i].code] = events[i].value;
break;
}
switch (events[i].type) {
case EV_SYN:
break;
case EV_KEY:
EvdevMotion (pi);
ASSIGNBIT(ke->key,events[i].code, events[i].value);
if (events[i].code < 0x100)
ErrorF ("key %d %d\n", events[i].code, events[i].value);
else
ErrorF ("key 0x%x %d\n", events[i].code, events[i].value);
break;
case EV_REL:
ke->rel[events[i].code] += events[i].value;
break;
case EV_ABS:
ke->abs[events[i].code] = events[i].value;
break;
}
}
EvdevMotion (mi);
EvdevMotion (pi);
}
int EvdevInputType;
@ -148,143 +150,153 @@ char *kdefaultEvdev[] = {
#define NUM_DEFAULT_EVDEV (sizeof (kdefaultEvdev) / sizeof (kdefaultEvdev[0]))
static Bool
EvdevInit (void)
static Status
EvdevInit (KdPointerInfo *pi)
{
int i;
int fd;
KdMouseInfo *mi, *next;
int n = 0;
char *prot;
int i;
int fd;
int n = 0;
char *prot;
if (!EvdevInputType)
EvdevInputType = KdAllocInputType ();
for (mi = kdMouseInfo; mi; mi = next)
{
next = mi->next;
prot = mi->prot;
if (mi->inputType)
continue;
if (!mi->name)
{
for (i = 0; i < NUM_DEFAULT_EVDEV; i++)
{
fd = open (kdefaultEvdev[i], 2);
if (fd >= 0)
{
mi->name = KdSaveString (kdefaultEvdev[i]);
break;
}
}
}
else
fd = open (mi->name, 2);
if (fd >= 0)
{
unsigned long ev[NBITS(EV_MAX)];
Kevdev *ke;
if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
{
perror ("EVIOCGBIT 0");
close (fd);
continue;
}
ke = xalloc (sizeof (Kevdev));
if (!ke)
{
close (fd);
continue;
}
memset (ke, '\0', sizeof (Kevdev));
if (ISBITSET (ev, EV_KEY))
{
if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
ke->keybits) < 0)
{
perror ("EVIOCGBIT EV_KEY");
xfree (ke);
close (fd);
continue;
}
}
if (ISBITSET (ev, EV_REL))
{
if (ioctl (fd, EVIOCGBIT (EV_REL, sizeof (ke->relbits)),
ke->relbits) < 0)
{
perror ("EVIOCGBIT EV_REL");
xfree (ke);
close (fd);
continue;
}
for (ke->max_rel = REL_MAX; ke->max_rel >= 0; ke->max_rel--)
if (ISBITSET(ke->relbits, ke->max_rel))
break;
}
if (ISBITSET (ev, EV_ABS))
{
int i;
if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
ke->absbits) < 0)
{
perror ("EVIOCGBIT EV_ABS");
xfree (ke);
close (fd);
continue;
}
for (ke->max_abs = ABS_MAX; ke->max_abs >= 0; ke->max_abs--)
if (ISBITSET(ke->absbits, ke->max_abs))
break;
for (i = 0; i <= ke->max_abs; i++)
{
if (ISBITSET (ke->absbits, i))
if (ioctl (fd, EVIOCGABS(i), &ke->absinfo[i]) < 0)
{
perror ("EVIOCGABS");
break;
}
ke->prevabs[i] = ABS_UNSET;
}
if (i <= ke->max_abs)
{
xfree (ke);
close (fd);
continue;
}
}
mi->driver = ke;
mi->inputType = EvdevInputType;
if (KdRegisterFd (EvdevInputType, fd, EvdevRead, (void *) mi))
n++;
}
if (!pi->path) {
for (i = 0; i < NUM_DEFAULT_EVDEV; i++) {
fd = open (kdefaultEvdev[i], 2);
if (fd >= 0) {
pi->path = KdSaveString (kdefaultEvdev[i]);
break;
}
}
}
return TRUE;
else {
fd = open (pi->path, 2);
if (fd < 0) {
ErrorF("Failed to open evdev device %s\n", pi->path);
return BadMatch;
}
}
return Success;
}
static Status
EvdevEnable (KdPointerInfo *pi)
{
int fd;
if (!pi || !pi->path)
return BadImplementation;
fd = open(pi->path, 2);
if (fd < 0)
return BadMatch;
unsigned long ev[NBITS(EV_MAX)];
Kevdev *ke;
if (ioctl (fd, EVIOCGBIT(0 /*EV*/, sizeof (ev)), ev) < 0)
{
perror ("EVIOCGBIT 0");
close (fd);
return BadMatch;
}
ke = xalloc (sizeof (Kevdev));
if (!ke)
{
close (fd);
return BadAlloc;
}
memset (ke, '\0', sizeof (Kevdev));
if (ISBITSET (ev, EV_KEY))
{
if (ioctl (fd, EVIOCGBIT (EV_KEY, sizeof (ke->keybits)),
ke->keybits) < 0)
{
perror ("EVIOCGBIT EV_KEY");
xfree (ke);
close (fd);
return BadMatch;
}
}
if (ISBITSET (ev, EV_REL))
{
if (ioctl (fd, EVIOCGBIT (EV_REL, sizeof (ke->relbits)),
ke->relbits) < 0)
{
perror ("EVIOCGBIT EV_REL");
xfree (ke);
close (fd);
return BadMatch;
}
for (ke->max_rel = REL_MAX; ke->max_rel >= 0; ke->max_rel--)
if (ISBITSET(ke->relbits, ke->max_rel))
break;
}
if (ISBITSET (ev, EV_ABS))
{
int i;
if (ioctl (fd, EVIOCGBIT (EV_ABS, sizeof (ke->absbits)),
ke->absbits) < 0)
{
perror ("EVIOCGBIT EV_ABS");
xfree (ke);
close (fd);
return BadMatch;
}
for (ke->max_abs = ABS_MAX; ke->max_abs >= 0; ke->max_abs--)
if (ISBITSET(ke->absbits, ke->max_abs))
break;
for (i = 0; i <= ke->max_abs; i++)
{
if (ISBITSET (ke->absbits, i))
if (ioctl (fd, EVIOCGABS(i), &ke->absinfo[i]) < 0)
{
perror ("EVIOCGABS");
break;
}
ke->prevabs[i] = ABS_UNSET;
}
if (i <= ke->max_abs)
{
xfree (ke);
close (fd);
return BadValue;
}
}
if (!KdRegisterFd (fd, EvdevRead, pi)) {
xfree (ke);
close (fd);
return BadAlloc;
}
pi->driverPrivate = ke;
return Success;
}
static void
EvdevFini (void)
EvdevDisable (KdPointerInfo *pi)
{
KdMouseInfo *mi;
Kevdev *ke;
KdUnregisterFds (EvdevInputType, TRUE);
for (mi = kdMouseInfo; mi; mi = mi->next)
{
if (mi->inputType == EvdevInputType)
{
xfree (mi->driver);
mi->driver = 0;
mi->inputType = 0;
}
}
if (!pi || !pi->driverPrivate)
return;
KdUnregisterFd (pi, ke->fd, TRUE);
xfree (ke);
pi->driverPrivate = 0;
}
KdMouseFuncs LinuxEvdevMouseFuncs = {
static void
EvdevFini (KdPointerInfo *pi)
{
}
KdPointerDriver LinuxEvdevMouseDriver = {
"evdev",
EvdevInit,
EvdevEnable,
EvdevDisable,
EvdevFini,
NULL,
};
#if 0

491
hw/kdrive/linux/keyboard.c
View File

@ -2,31 +2,40 @@
* $RCSId: xc/programs/Xserver/hw/kdrive/linux/keyboard.c,v 1.10 2001/11/08 10:26:24 keithp Exp $
*
* Copyright © 1999 Keith Packard
* XKB integration © 2006 Nokia Corporation, author: Tomas Frydrych <tf@o-hand.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 of Keith Packard not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
* LinuxKeyboardRead() XKB code based on xf86KbdLnx.c:
* Copyright © 1990,91 by Thomas Roell, Dinkelscherben, Germany.
* Copyright © 1994-2001 by The XFree86 Project, Inc.
*
* KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL KEITH PACKARD 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.
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
#ifdef HAVE_CONFIG_H
#include <kdrive-config.h>
#endif
#include "kdrive.h"
#include "kkeymap.h"
#include <linux/keyboard.h>
#include <linux/kd.h>
#define XK_PUBLISHING
@ -34,7 +43,7 @@
#include <termios.h>
#include <sys/ioctl.h>
extern int LinuxConsoleFd;
extern int LinuxConsoleFd;
static const KeySym linux_to_x[256] = {
NoSymbol, NoSymbol, NoSymbol, NoSymbol,
@ -103,7 +112,108 @@ static const KeySym linux_to_x[256] = {
XK_udiaeresis, XK_yacute, XK_thorn, XK_ydiaeresis
};
static unsigned char tbl[KD_MAX_WIDTH] =
#ifdef XKB
/*
* Getting a keycode from scancode
*
* With XKB
* --------
*
* We have to enqueue keyboard events using standard X keycodes which correspond
* to AT scancode + 8; this means that we need to translate the Linux scancode
* provided by the kernel to an AT scancode -- this translation is not linear
* and requires that we use a LUT.
*
*
* Without XKB
* -----------
*
* We can use custom keycodes, which makes things simpler; we define our custom
* keycodes as Linux scancodes + KD_KEY_OFFSET
*/
/*
This LUT translates AT scancodes into Linux ones -- the keymap we create
for the core X keyboard protocol has to be AT-scancode based so that it
corresponds to the Xkb keymap.
*/
static unsigned char at2lnx[] =
{
0x0, /* no valid scancode */
0x01, /* KEY_Escape */ 0x02, /* KEY_1 */
0x03, /* KEY_2 */ 0x04, /* KEY_3 */
0x05, /* KEY_4 */ 0x06, /* KEY_5 */
0x07, /* KEY_6 */ 0x08, /* KEY_7 */
0x09, /* KEY_8 */ 0x0a, /* KEY_9 */
0x0b, /* KEY_0 */ 0x0c, /* KEY_Minus */
0x0d, /* KEY_Equal */ 0x0e, /* KEY_BackSpace */
0x0f, /* KEY_Tab */ 0x10, /* KEY_Q */
0x11, /* KEY_W */ 0x12, /* KEY_E */
0x13, /* KEY_R */ 0x14, /* KEY_T */
0x15, /* KEY_Y */ 0x16, /* KEY_U */
0x17, /* KEY_I */ 0x18, /* KEY_O */
0x19, /* KEY_P */ 0x1a, /* KEY_LBrace */
0x1b, /* KEY_RBrace */ 0x1c, /* KEY_Enter */
0x1d, /* KEY_LCtrl */ 0x1e, /* KEY_A */
0x1f, /* KEY_S */ 0x20, /* KEY_D */
0x21, /* KEY_F */ 0x22, /* KEY_G */
0x23, /* KEY_H */ 0x24, /* KEY_J */
0x25, /* KEY_K */ 0x26, /* KEY_L */
0x27, /* KEY_SemiColon */ 0x28, /* KEY_Quote */
0x29, /* KEY_Tilde */ 0x2a, /* KEY_ShiftL */
0x2b, /* KEY_BSlash */ 0x2c, /* KEY_Z */
0x2d, /* KEY_X */ 0x2e, /* KEY_C */
0x2f, /* KEY_V */ 0x30, /* KEY_B */
0x31, /* KEY_N */ 0x32, /* KEY_M */
0x33, /* KEY_Comma */ 0x34, /* KEY_Period */
0x35, /* KEY_Slash */ 0x36, /* KEY_ShiftR */
0x37, /* KEY_KP_Multiply */ 0x38, /* KEY_Alt */
0x39, /* KEY_Space */ 0x3a, /* KEY_CapsLock */
0x3b, /* KEY_F1 */ 0x3c, /* KEY_F2 */
0x3d, /* KEY_F3 */ 0x3e, /* KEY_F4 */
0x3f, /* KEY_F5 */ 0x40, /* KEY_F6 */
0x41, /* KEY_F7 */ 0x42, /* KEY_F8 */
0x43, /* KEY_F9 */ 0x44, /* KEY_F10 */
0x45, /* KEY_NumLock */ 0x46, /* KEY_ScrollLock */
0x47, /* KEY_KP_7 */ 0x48, /* KEY_KP_8 */
0x49, /* KEY_KP_9 */ 0x4a, /* KEY_KP_Minus */
0x4b, /* KEY_KP_4 */ 0x4c, /* KEY_KP_5 */
0x4d, /* KEY_KP_6 */ 0x4e, /* KEY_KP_Plus */
0x4f, /* KEY_KP_1 */ 0x50, /* KEY_KP_2 */
0x51, /* KEY_KP_3 */ 0x52, /* KEY_KP_0 */
0x53, /* KEY_KP_Decimal */ 0x54, /* KEY_SysReqest */
0x00, /* 0x55 */ 0x56, /* KEY_Less */
0x57, /* KEY_F11 */ 0x58, /* KEY_F12 */
0x66, /* KEY_Home */ 0x67, /* KEY_Up */
0x68, /* KEY_PgUp */ 0x69, /* KEY_Left */
0x5d, /* KEY_Begin */ 0x6a, /* KEY_Right */
0x6b, /* KEY_End */ 0x6c, /* KEY_Down */
0x6d, /* KEY_PgDown */ 0x6e, /* KEY_Insert */
0x6f, /* KEY_Delete */ 0x60, /* KEY_KP_Enter */
0x61, /* KEY_RCtrl */ 0x77, /* KEY_Pause */
0x63, /* KEY_Print */ 0x62, /* KEY_KP_Divide */
0x64, /* KEY_AltLang */ 0x65, /* KEY_Break */
0x00, /* KEY_LMeta */ 0x00, /* KEY_RMeta */
0x7A, /* KEY_Menu/FOCUS_PF11*/0x00, /* 0x6e */
0x7B, /* FOCUS_PF12 */ 0x00, /* 0x70 */
0x00, /* 0x71 */ 0x00, /* 0x72 */
0x59, /* FOCUS_PF2 */ 0x78, /* FOCUS_PF9 */
0x00, /* 0x75 */ 0x00, /* 0x76 */
0x5A, /* FOCUS_PF3 */ 0x5B, /* FOCUS_PF4 */
0x5C, /* FOCUS_PF5 */ 0x5D, /* FOCUS_PF6 */
0x5E, /* FOCUS_PF7 */ 0x5F, /* FOCUS_PF8 */
0x7C, /* JAP_86 */ 0x79, /* FOCUS_PF10 */
0x00, /* 0x7f */
};
#define NUM_AT_KEYS (sizeof(at2lnx)/sizeof(at2lnx[0]))
#define LNX_KEY_INDEX(n) n < NUM_AT_KEYS ? at2lnx[n] : 0
#else /* not XKB */
#define LNX_KEY_INDEX(n) n
#endif
static unsigned char tbl[KD_MAX_WIDTH] =
{
0,
1 << KG_SHIFT,
@ -112,24 +222,31 @@ static unsigned char tbl[KD_MAX_WIDTH] =
};
static void
readKernelMapping(void)
readKernelMapping(KdKeyboardInfo *ki)
{
KeySym *k;
int i, j;
struct kbentry kbe;
int minKeyCode, maxKeyCode;
int row;
int fd;
if (!ki)
return;
fd = LinuxConsoleFd;
minKeyCode = NR_KEYS;
maxKeyCode = 0;
row = 0;
ki->keySyms.mapWidth = KD_MAX_WIDTH;
for (i = 0; i < NR_KEYS && row < KD_MAX_LENGTH; ++i)
{
kbe.kb_index = i;
kbe.kb_index = LNX_KEY_INDEX(i);
k = kdKeymap + row * KD_MAX_WIDTH;
k = ki->keySyms.map + row * ki->keySyms.mapWidth;
for (j = 0; j < KD_MAX_WIDTH; ++j)
for (j = 0; j < ki->keySyms.mapWidth; ++j)
{
unsigned short kval;
@ -137,7 +254,7 @@ readKernelMapping(void)
kbe.kb_table = tbl[j];
kbe.kb_value = 0;
if (ioctl(LinuxConsoleFd, KDGKBENT, &kbe))
if (ioctl(fd, KDGKBENT, &kbe))
continue;
kval = KVAL(kbe.kb_value);
@ -362,7 +479,7 @@ readKernelMapping(void)
if (minKeyCode == NR_KEYS)
continue;
if (k[3] == k[2]) k[3] = NoSymbol;
if (k[2] == k[1]) k[2] = NoSymbol;
if (k[1] == k[0]) k[1] = NoSymbol;
@ -370,28 +487,223 @@ readKernelMapping(void)
if (k[3] == k[0] && k[2] == k[1] && k[2] == NoSymbol) k[3] =NoSymbol;
row++;
}
kdMinScanCode = minKeyCode;
kdMaxScanCode = maxKeyCode;
ki->minScanCode = minKeyCode;
ki->maxScanCode = maxKeyCode;
}
static void
LinuxKeyboardLoad (void)
{
readKernelMapping ();
}
#ifdef XKB
/*
* We need these to handle extended scancodes correctly (I could just use the
* numbers below, but this makes the code more readable
*/
/* The prefix codes */
#define KEY_Prefix0 /* special 0x60 */ 96
#define KEY_Prefix1 /* special 0x61 */ 97
/* The raw scancodes */
#define KEY_Enter /* Enter 0x1c */ 28
#define KEY_LCtrl /* Ctrl(left) 0x1d */ 29
#define KEY_Slash /* / (Slash) ? 0x35 */ 53
#define KEY_KP_Multiply /* * 0x37 */ 55
#define KEY_Alt /* Alt(left) 0x38 */ 56
#define KEY_F3 /* F3 0x3d */ 61
#define KEY_F4 /* F4 0x3e */ 62
#define KEY_F5 /* F5 0x3f */ 63
#define KEY_F6 /* F6 0x40 */ 64
#define KEY_F7 /* F7 0x41 */ 65
#define KEY_ScrollLock /* ScrollLock 0x46 */ 70
#define KEY_KP_7 /* 7 Home 0x47 */ 71
#define KEY_KP_8 /* 8 Up 0x48 */ 72
#define KEY_KP_9 /* 9 PgUp 0x49 */ 73
#define KEY_KP_Minus /* - (Minus) 0x4a */ 74
#define KEY_KP_4 /* 4 Left 0x4b */ 75
#define KEY_KP_5 /* 5 0x4c */ 76
#define KEY_KP_6 /* 6 Right 0x4d */ 77
#define KEY_KP_Plus /* + (Plus) 0x4e */ 78
#define KEY_KP_1 /* 1 End 0x4f */ 79
#define KEY_KP_2 /* 2 Down 0x50 */ 80
#define KEY_KP_3 /* 3 PgDown 0x51 */ 81
#define KEY_KP_0 /* 0 Insert 0x52 */ 82
#define KEY_KP_Decimal /* . (Decimal) Delete 0x53 */ 83
#define KEY_Home /* Home 0x59 */ 89
#define KEY_Up /* Up 0x5a */ 90
#define KEY_PgUp /* PgUp 0x5b */ 91
#define KEY_Left /* Left 0x5c */ 92
#define KEY_Begin /* Begin 0x5d */ 93
#define KEY_Right /* Right 0x5e */ 94
#define KEY_End /* End 0x5f */ 95
#define KEY_Down /* Down 0x60 */ 96
#define KEY_PgDown /* PgDown 0x61 */ 97
#define KEY_Insert /* Insert 0x62 */ 98
#define KEY_Delete /* Delete 0x63 */ 99
#define KEY_KP_Enter /* Enter 0x64 */ 100
#define KEY_RCtrl /* Ctrl(right) 0x65 */ 101
#define KEY_Pause /* Pause 0x66 */ 102
#define KEY_Print /* Print 0x67 */ 103
#define KEY_KP_Divide /* Divide 0x68 */ 104
#define KEY_AltLang /* AtlLang(right) 0x69 */ 105
#define KEY_Break /* Break 0x6a */ 106
#define KEY_LMeta /* Left Meta 0x6b */ 107
#define KEY_RMeta /* Right Meta 0x6c */ 108
#define KEY_Menu /* Menu 0x6d */ 109
#define KEY_F13 /* F13 0x6e */ 110
#define KEY_F14 /* F14 0x6f */ 111
#define KEY_F15 /* F15 0x70 */ 112
#define KEY_F16 /* F16 0x71 */ 113
#define KEY_F17 /* F17 0x72 */ 114
#define KEY_KP_DEC /* KP_DEC 0x73 */ 115
#endif /* XKB */
static void
LinuxKeyboardRead (int fd, void *closure)
{
unsigned char buf[256], *b;
int n;
unsigned char prefix = 0, scancode = 0;
while ((n = read (fd, buf, sizeof (buf))) > 0)
{
while ((n = read (fd, buf, sizeof (buf))) > 0) {
b = buf;
while (n--)
{
KdEnqueueKeyboardEvent (b[0] & 0x7f, b[0] & 0x80);
while (n--) {
#ifdef XKB
if (!noXkbExtension) {
/*
* With xkb we use RAW mode for reading the console, which allows us
* process extended scancodes.
*
* See if this is a prefix extending the following keycode
*/
if (!prefix && ((b[0] & 0x7f) == KEY_Prefix0))
{
prefix = KEY_Prefix0;
#ifdef DEBUG
ErrorF("Prefix0");
#endif
/* swallow this up */
b++;
continue;
}
else if (!prefix && ((b[0] & 0x7f) == KEY_Prefix1))
{
prefix = KEY_Prefix1;
ErrorF("Prefix1");
/* swallow this up */
b++;
continue;
}
scancode = b[0] & 0x7f;
switch (prefix) {
/* from xf86Events.c */
case KEY_Prefix0:
{
#ifdef DEBUG
ErrorF("Prefix0 scancode: 0x%02x\n", scancode);
#endif
switch (scancode) {
case KEY_KP_7:
scancode = KEY_Home; break; /* curs home */
case KEY_KP_8:
scancode = KEY_Up; break; /* curs up */
case KEY_KP_9:
scancode = KEY_PgUp; break; /* curs pgup */
case KEY_KP_4:
scancode = KEY_Left; break; /* curs left */
case KEY_KP_5:
scancode = KEY_Begin; break; /* curs begin */
case KEY_KP_6:
scancode = KEY_Right; break; /* curs right */
case KEY_KP_1:
scancode = KEY_End; break; /* curs end */
case KEY_KP_2:
scancode = KEY_Down; break; /* curs down */
case KEY_KP_3:
scancode = KEY_PgDown; break; /* curs pgdown */
case KEY_KP_0:
scancode = KEY_Insert; break; /* curs insert */
case KEY_KP_Decimal:
scancode = KEY_Delete; break; /* curs delete */
case KEY_Enter:
scancode = KEY_KP_Enter; break; /* keypad enter */
case KEY_LCtrl:
scancode = KEY_RCtrl; break; /* right ctrl */
case KEY_KP_Multiply:
scancode = KEY_Print; break; /* print */
case KEY_Slash:
scancode = KEY_KP_Divide; break; /* keyp divide */
case KEY_Alt:
scancode = KEY_AltLang; break; /* right alt */
case KEY_ScrollLock:
scancode = KEY_Break; break; /* curs break */
case 0x5b:
scancode = KEY_LMeta; break;
case 0x5c:
scancode = KEY_RMeta; break;
case 0x5d:
scancode = KEY_Menu; break;
case KEY_F3:
scancode = KEY_F13; break;
case KEY_F4:
scancode = KEY_F14; break;
case KEY_F5:
scancode = KEY_F15; break;
case KEY_F6:
scancode = KEY_F16; break;
case KEY_F7:
scancode = KEY_F17; break;
case KEY_KP_Plus:
scancode = KEY_KP_DEC; break;
/* Ignore virtual shifts (E0 2A, E0 AA, E0 36, E0 B6) */
case 0x2A:
case 0x36:
b++;
prefix = 0;
continue;
default:
#ifdef DEBUG
ErrorF("Unreported Prefix0 scancode: 0x%02x\n",
scancode);
#endif
/*
* "Internet" keyboards are generating lots of new
* codes. Let them pass. There is little consistency
* between them, so don't bother with symbolic names at
* this level.
*/
scancode += 0x78;
}
break;
}
case KEY_Prefix1:
{
/* we do no handle these */
#ifdef DEBUG
ErrorF("Prefix1 scancode: 0x%02x\n", scancode);
#endif
b++;
prefix = 0;
continue;
}
default: /* should not happen*/
case 0: /* do nothing */
#ifdef DEBUG
ErrorF("Plain scancode: 0x%02x\n", scancode);
#endif
;
}
prefix = 0;
}
/* without xkb we use mediumraw mode -- enqueue the scancode as is */
else
#endif
scancode = b[0] & 0x7f;
KdEnqueueKeyboardEvent (closure, scancode, b[0] & 0x80);
b++;
}
}
@ -399,19 +711,30 @@ LinuxKeyboardRead (int fd, void *closure)
static int LinuxKbdTrans;
static struct termios LinuxTermios;
static int LinuxKbdType;
static int
LinuxKeyboardEnable (int fd, void *closure)
static Status
LinuxKeyboardEnable (KdKeyboardInfo *ki)
{
struct termios nTty;
unsigned char buf[256];
int n;
int fd;
if (!ki)
return !Success;
fd = LinuxConsoleFd;
ki->driverPrivate = (void *) fd;
ioctl (fd, KDGKBMODE, &LinuxKbdTrans);
tcgetattr (fd, &LinuxTermios);
ioctl(fd, KDSKBMODE, K_MEDIUMRAW);
#ifdef XKB
if (!noXkbExtension)
ioctl(fd, KDSKBMODE, K_RAW);
else
#else
ioctl(fd, KDSKBMODE, K_MEDIUMRAW);
#endif
nTty = LinuxTermios;
nTty.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
nTty.c_oflag = 0;
@ -422,66 +745,64 @@ LinuxKeyboardEnable (int fd, void *closure)
cfsetispeed(&nTty, 9600);
cfsetospeed(&nTty, 9600);
tcsetattr(fd, TCSANOW, &nTty);
/* Our kernel cleverly ignores O_NONBLOCK. Sigh. */
#if 0
/*
* Flush any pending keystrokes
*/
while ((n = read (fd, buf, sizeof (buf))) > 0)
;
return fd;
#endif
KdRegisterFd (fd, LinuxKeyboardRead, ki);
return Success;
}
static void
LinuxKeyboardDisable (int fd, void *closure)
LinuxKeyboardDisable (KdKeyboardInfo *ki)
{
ioctl(LinuxConsoleFd, KDSKBMODE, LinuxKbdTrans);
tcsetattr(LinuxConsoleFd, TCSANOW, &LinuxTermios);
int fd;
if (!ki)
return;
fd = (int) ki->driverPrivate;
KdUnregisterFd(ki, fd, FALSE);
ioctl(fd, KDSKBMODE, LinuxKbdTrans);
tcsetattr(fd, TCSANOW, &LinuxTermios);
}
static int
LinuxKeyboardInit (void)
static Status
LinuxKeyboardInit (KdKeyboardInfo *ki)
{
if (!LinuxKbdType)
LinuxKbdType = KdAllocInputType ();
if (!ki)
return !Success;
KdRegisterFd (LinuxKbdType, LinuxConsoleFd, LinuxKeyboardRead, 0);
LinuxKeyboardEnable (LinuxConsoleFd, 0);
KdRegisterFdEnableDisable (LinuxConsoleFd,
LinuxKeyboardEnable,
LinuxKeyboardDisable);
return 1;
if (ki->path)
xfree(ki->path);
ki->path = KdSaveString("console");
if (ki->name)
xfree(ki->name);
ki->name = KdSaveString("Linux console keyboard");
readKernelMapping (ki);
return Success;
}
static void
LinuxKeyboardFini (void)
LinuxKeyboardLeds (KdKeyboardInfo *ki, int leds)
{
LinuxKeyboardDisable (LinuxConsoleFd, 0);
KdUnregisterFds (LinuxKbdType, FALSE);
if (!ki)
return;
ioctl ((int)ki->driverPrivate, KDSETLED, leds & 7);
}
static void
LinuxKeyboardLeds (int leds)
{
ioctl (LinuxConsoleFd, KDSETLED, leds & 7);
}
static void
LinuxKeyboardBell (int volume, int pitch, int duration)
{
if (volume && pitch)
{
ioctl(LinuxConsoleFd, KDMKTONE,
((1193190 / pitch) & 0xffff) |
(((unsigned long)duration *
volume / 50) << 16));
}
}
KdKeyboardFuncs LinuxKeyboardFuncs = {
LinuxKeyboardLoad,
LinuxKeyboardInit,
LinuxKeyboardLeds,
LinuxKeyboardBell,
LinuxKeyboardFini,
3,
KdKeyboardDriver LinuxKeyboardDriver = {
"keyboard",
.Init = LinuxKeyboardInit,
.Enable = LinuxKeyboardEnable,
.Leds = LinuxKeyboardLeds,
.Disable = LinuxKeyboardDisable,
};

52
hw/kdrive/linux/linux.c
View File

@ -373,26 +373,6 @@ LinuxEnable (void)
enabled = TRUE;
}
static Bool
LinuxSpecialKey (KeySym sym)
{
struct vt_stat vts;
int con;
if (XK_F1 <= sym && sym <= XK_F12)
{
con = sym - XK_F1 + 1;
memset (&vts, '\0', sizeof (vts)); /* valgrind */
ioctl (LinuxConsoleFd, VT_GETSTATE, &vts);
if (con != vts.v_active && (vts.v_state & (1 << con)))
{
ioctl (LinuxConsoleFd, VT_ACTIVATE, con);
return TRUE;
}
}
return FALSE;
}
static void
LinuxDisable (void)
{
@ -456,6 +436,7 @@ LinuxFini (void)
}
}
close(LinuxConsoleFd); /* make the vt-manager happy */
LinuxConsoleFd = -1;
fd = open ("/dev/tty0", O_RDWR|O_NDELAY, 0);
if (fd >= 0)
{
@ -468,13 +449,32 @@ LinuxFini (void)
return;
}
void
KdOsAddInputDrivers ()
{
KdAddPointerDriver(&LinuxMouseDriver);
KdAddPointerDriver(&MsMouseDriver);
KdAddPointerDriver(&Ps2MouseDriver);
#ifdef TSLIB
KdAddPointerDriver(&TsDriver);
#endif
KdAddKeyboardDriver(&LinuxKeyboardDriver);
}
static void
LinuxBell(int volume, int pitch, int duration)
{
if (volume && pitch)
ioctl(LinuxConsoleFd, KDMKTONE, ((1193190 / pitch) & 0xffff) |
(((unsigned long)duration * volume / 50) << 16));
}
KdOsFuncs LinuxFuncs = {
LinuxInit,
LinuxEnable,
LinuxSpecialKey,
LinuxDisable,
LinuxFini,
0
.Init = LinuxInit,
.Enable = LinuxEnable,
.Disable = LinuxDisable,
.Fini = LinuxFini,
.Bell = LinuxBell,
};
void

242
hw/kdrive/linux/mouse.c
View File

@ -206,10 +206,10 @@ MouseWriteBytes (int fd, unsigned char *c, int n, int timeout)
typedef struct _kmouseProt {
char *name;
Bool (*Complete) (KdMouseInfo *mi, unsigned char *ev, int ne);
int (*Valid) (KdMouseInfo *mi, unsigned char *ev, int ne);
Bool (*Parse) (KdMouseInfo *mi, unsigned char *ev, int ne);
Bool (*Init) (KdMouseInfo *mi);
Bool (*Complete) (KdPointerInfo *pi, unsigned char *ev, int ne);
int (*Valid) (KdPointerInfo *pi, unsigned char *ev, int ne);
Bool (*Parse) (KdPointerInfo *pi, unsigned char *ev, int ne);
Bool (*Init) (KdPointerInfo *pi);
unsigned char headerMask, headerValid;
unsigned char dataMask, dataValid;
Bool tty;
@ -238,9 +238,9 @@ typedef struct _kmouse {
unsigned long state; /* private per protocol, init to prot->state */
} Kmouse;
static int mouseValid (KdMouseInfo *mi, unsigned char *ev, int ne)
static int mouseValid (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
const KmouseProt *prot = km->prot;
int i;
@ -255,24 +255,24 @@ static int mouseValid (KdMouseInfo *mi, unsigned char *ev, int ne)
return 0;
}
static Bool threeComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool threeComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
{
return ne == 3;
}
static Bool fourComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool fourComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
{
return ne == 4;
}
static Bool fiveComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool fiveComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
{
return ne == 5;
}
static Bool MouseReasonable (KdMouseInfo *mi, unsigned long flags, int dx, int dy)
static Bool MouseReasonable (KdPointerInfo *pi, unsigned long flags, int dx, int dy)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
if (km->stage == MouseWorking)
return TRUE;
@ -296,9 +296,9 @@ static Bool MouseReasonable (KdMouseInfo *mi, unsigned long flags, int dx, int d
/*
* Standard PS/2 mouse protocol
*/
static Bool ps2Parse (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool ps2Parse (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int dx, dy, dz;
unsigned long flags;
unsigned long flagsrelease = 0;
@ -333,21 +333,21 @@ static Bool ps2Parse (KdMouseInfo *mi, unsigned char *ev, int ne)
if (ev[0] & 0x20)
dy -= 256;
dy = -dy;
if (!MouseReasonable (mi, flags, dx, dy))
if (!MouseReasonable (pi, flags, dx, dy))
return FALSE;
if (km->stage == MouseWorking)
{
KdEnqueueMouseEvent (mi, flags, dx, dy);
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
if (flagsrelease)
{
flags &= ~flagsrelease;
KdEnqueueMouseEvent (mi, flags, dx, dy);
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
}
}
return TRUE;
}
static Bool ps2Init (KdMouseInfo *mi);
static Bool ps2Init (KdPointerInfo *pi);
static const KmouseProt ps2Prot = {
"ps/2",
@ -450,9 +450,9 @@ static unsigned char intelli_init[] = {
#define NINIT_INTELLI 3
static int
ps2SkipInit (KdMouseInfo *mi, int ninit, Bool ret_next)
ps2SkipInit (KdPointerInfo *pi, int ninit, Bool ret_next)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int c = -1;
int skipping;
Bool waiting;
@ -481,9 +481,9 @@ ps2SkipInit (KdMouseInfo *mi, int ninit, Bool ret_next)
}
static Bool
ps2Init (KdMouseInfo *mi)
ps2Init (KdPointerInfo *pi)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int skipping;
Bool waiting;
int id;
@ -499,7 +499,7 @@ ps2Init (KdMouseInfo *mi)
return FALSE;
skipping = 0;
waiting = FALSE;
id = ps2SkipInit (mi, 0, TRUE);
id = ps2SkipInit (pi, 0, TRUE);
switch (id) {
case 3:
init = wheel_3button_init;
@ -524,13 +524,13 @@ ps2Init (KdMouseInfo *mi)
* initialization string. Make sure any partial event is
* skipped
*/
(void) ps2SkipInit (mi, ninit, FALSE);
(void) ps2SkipInit (pi, ninit, FALSE);
return TRUE;
}
static Bool busParse (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool busParse (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int dx, dy;
unsigned long flags;
@ -543,10 +543,10 @@ static Bool busParse (KdMouseInfo *mi, unsigned char *ev, int ne)
flags |= KD_BUTTON_2;
if ((ev[0] & 1) == 0)
flags |= KD_BUTTON_3;
if (!MouseReasonable (mi, flags, dx, dy))
if (!MouseReasonable (pi, flags, dx, dy))
return FALSE;
if (km->stage == MouseWorking)
KdEnqueueMouseEvent (mi, flags, dx, dy);
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
return TRUE;
}
@ -561,9 +561,9 @@ static const KmouseProt busProt = {
* Standard MS serial protocol, three bytes
*/
static Bool msParse (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool msParse (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int dx, dy;
unsigned long flags;
@ -576,10 +576,10 @@ static Bool msParse (KdMouseInfo *mi, unsigned char *ev, int ne)
dx = (signed char)(((ev[0] & 0x03) << 6) | (ev[1] & 0x3F));
dy = (signed char)(((ev[0] & 0x0C) << 4) | (ev[2] & 0x3F));
if (!MouseReasonable (mi, flags, dx, dy))
if (!MouseReasonable (pi, flags, dx, dy))
return FALSE;
if (km->stage == MouseWorking)
KdEnqueueMouseEvent (mi, flags, dx, dy);
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
return TRUE;
}
@ -600,9 +600,9 @@ static const KmouseProt msProt = {
* first byte of a synchronized protocol stream and see if it's got
* any bits turned on that can't occur in that fourth byte
*/
static Bool logiComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool logiComplete (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
if ((ev[0] & 0x40) == 0x40)
return ne == 3;
@ -611,9 +611,9 @@ static Bool logiComplete (KdMouseInfo *mi, unsigned char *ev, int ne)
return FALSE;
}
static int logiValid (KdMouseInfo *mi, unsigned char *ev, int ne)
static int logiValid (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
const KmouseProt *prot = km->prot;
int i;
@ -632,9 +632,9 @@ static int logiValid (KdMouseInfo *mi, unsigned char *ev, int ne)
return 0;
}
static Bool logiParse (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool logiParse (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int dx, dy;
unsigned long flags;
@ -660,10 +660,10 @@ static Bool logiParse (KdMouseInfo *mi, unsigned char *ev, int ne)
flags |= km->state & (KD_BUTTON_1|KD_BUTTON_3);
}
if (!MouseReasonable (mi, flags, dx, dy))
if (!MouseReasonable (pi, flags, dx, dy))
return FALSE;
if (km->stage == MouseWorking)
KdEnqueueMouseEvent (mi, flags, dx, dy);
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
return TRUE;
}
@ -682,9 +682,9 @@ static const KmouseProt logiProt = {
/*
* Mouse systems protocol, 5 bytes
*/
static Bool mscParse (KdMouseInfo *mi, unsigned char *ev, int ne)
static Bool mscParse (KdPointerInfo *pi, unsigned char *ev, int ne)
{
Kmouse *km = mi->driver;
Kmouse *km = pi->driverPrivate;
int dx, dy;
unsigned long flags;
@ -699,10 +699,10 @@ static Bool mscParse (KdMouseInfo *mi, unsigned char *ev, int ne)
dx = (signed char)(ev[1]) + (signed char)(ev[3]);
dy = - ((signed char)(ev[2]) + (signed char)(ev[4]));
if (!MouseReasonable (mi, flags, dx, dy))
if (!MouseReasonable (pi, flags, dx, dy))
return FALSE;
if (km->stage == MouseWorking)
KdEnqueueMouseEvent (mi, flags, dx, dy);
KdEnqueuePointerEvent (pi, flags, dx, dy, 0);
return TRUE;
}
@ -810,8 +810,8 @@ MouseNextProtocol (Kmouse *km)
static void
MouseRead (int mousePort, void *closure)
{
KdMouseInfo *mi = closure;
Kmouse *km = mi->driver;
KdPointerInfo *pi = closure;
Kmouse *km = pi->driverPrivate;
unsigned char event[MAX_MOUSE];
int ne;
int c;
@ -835,7 +835,7 @@ MouseRead (int mousePort, void *closure)
break;
}
event[ne++] = c;
i = (*km->prot->Valid) (mi, event, ne);
i = (*km->prot->Valid) (pi, event, ne);
if (i != 0)
{
#ifdef DEBUG
@ -867,9 +867,9 @@ MouseRead (int mousePort, void *closure)
}
else
{
if ((*km->prot->Complete) (mi, event, ne))
if ((*km->prot->Complete) (pi, event, ne))
{
if ((*km->prot->Parse) (mi, event, ne))
if ((*km->prot->Parse) (pi, event, ne))
{
switch (km->stage)
{
@ -896,7 +896,7 @@ MouseRead (int mousePort, void *closure)
km->invalid = 0;
km->tested = 0;
km->valid = 0;
if (km->prot->Init && !(*km->prot->Init) (mi))
if (km->prot->Init && !(*km->prot->Init) (pi))
km->stage = MouseBroken;
}
break;
@ -923,9 +923,9 @@ MouseRead (int mousePort, void *closure)
int MouseInputType;
char *kdefaultMouse[] = {
"/dev/input/mice",
"/dev/mouse",
"/dev/psaux",
"/dev/input/mice",
"/dev/adbmouse",
"/dev/ttyS0",
"/dev/ttyS1",
@ -933,81 +933,97 @@ char *kdefaultMouse[] = {
#define NUM_DEFAULT_MOUSE (sizeof (kdefaultMouse) / sizeof (kdefaultMouse[0]))
static Bool
MouseInit (void)
static Status
MouseInit (KdPointerInfo *pi)
{
int i;
int fd;
Kmouse *km;
KdMouseInfo *mi, *next;
int n = 0;
char *prot;
if (!MouseInputType)
MouseInputType = KdAllocInputType ();
for (mi = kdMouseInfo; mi; mi = next)
{
next = mi->next;
prot = mi->prot;
if (mi->inputType)
continue;
if (!mi->name)
{
for (i = 0; i < NUM_DEFAULT_MOUSE; i++)
{
fd = open (kdefaultMouse[i], 2);
if (fd >= 0)
{
mi->name = KdSaveString (kdefaultMouse[i]);
break;
}
}
}
else
fd = open (mi->name, 2);
if (fd >= 0)
{
km = (Kmouse *) xalloc (sizeof (Kmouse));
if (km)
{
km->iob.fd = fd;
km->iob.avail = km->iob.used = 0;
km->prot = 0;
km->i_prot = 0;
km->tty = isatty (fd);
mi->driver = km;
mi->inputType = MouseInputType;
MouseFirstProtocol (km, mi->prot);
if (KdRegisterFd (MouseInputType, fd, MouseRead, (void *) mi))
n++;
}
else
close (fd);
}
if (!pi)
return BadImplementation;
if (!pi->path || strcmp(pi->path, "auto") == 0) {
for (i = 0; i < NUM_DEFAULT_MOUSE; i++) {
fd = open (kdefaultMouse[i], 2);
if (fd >= 0) {
pi->path = KdSaveString (kdefaultMouse[i]);
break;
}
}
}
return TRUE;
else {
fd = open (pi->path, 2);
}
if (fd < 0)
return BadMatch;
close(fd);
km = (Kmouse *) xalloc (sizeof (Kmouse));
if (km) {
km->iob.avail = km->iob.used = 0;
MouseFirstProtocol(km, "exps/2");
km->i_prot = 0;
km->tty = isatty (fd);
km->iob.fd = -1;
pi->driverPrivate = km;
}
else {
close (fd);
return BadAlloc;
}
return Success;
}
static Status
MouseEnable (KdPointerInfo *pi)
{
Kmouse *km;
if (!pi || !pi->driverPrivate || !pi->path)
return BadImplementation;
km = pi->driverPrivate;
km->iob.fd = open(pi->path, 2);
if (km->iob.fd < 0)
return BadMatch;
if (!KdRegisterFd (km->iob.fd, MouseRead, pi))
{
close(km->iob.fd);
return BadAlloc;
}
return Success;
}
static void
MouseFini (void)
MouseDisable (KdPointerInfo *pi)
{
KdMouseInfo *mi;
KdUnregisterFds (MouseInputType, TRUE);
for (mi = kdMouseInfo; mi; mi = mi->next)
{
if (mi->inputType == MouseInputType)
{
xfree (mi->driver);
mi->driver = 0;
mi->inputType = 0;
}
}
Kmouse *km;
if (!pi || !pi->driverPrivate)
return;
km = pi->driverPrivate;
KdUnregisterFd (pi, km->iob.fd, TRUE);
}
KdMouseFuncs LinuxMouseFuncs = {
static void
MouseFini (KdPointerInfo *pi)
{
xfree (pi->driverPrivate);
pi->driverPrivate = NULL;
}
KdPointerDriver LinuxMouseDriver = {
"mouse",
MouseInit,
MouseEnable,
MouseDisable,
MouseFini,
NULL,
};

61
hw/kdrive/linux/ms.c
View File

@ -90,41 +90,50 @@ MsRead (int port, void *closure)
dy = (char)(((b[0] & 0x0C) << 4) | (b[2] & 0x3F));
n -= 3;
b += 3;
KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
}
}
}
int MsInputType;
static Status
MsInit (KdPointerInfo *pi)
{
if (!pi)
return BadImplementation;
static int
MsInit (void)
if (!pi->path || strcmp(pi->path, "auto"))
pi->path = KdSaveString("/dev/mouse");
if (!pi->name)
pi->name = KdSaveString("Microsoft protocol mouse");
return Success;
}
static Status
MsEnable (KdPointerInfo *pi)
{
int port;
char *device = "/dev/mouse";
struct termios t;
int ret;
if (!MsInputType)
MsInputType = KdAllocInputType ();
port = open (device, O_RDWR | O_NONBLOCK);
port = open (pi->path, O_RDWR | O_NONBLOCK);
if(port < 0) {
ErrorF("Couldn't open %s (%d)\n", device, (int)errno);
ErrorF("Couldn't open %s (%d)\n", pi->path, (int)errno);
return 0;
} else if (port == 0) {
ErrorF("Opening %s returned 0! Please complain to Keith.\n",
device);
pi->path);
goto bail;
}
if(!isatty(port)) {
ErrorF("%s is not a tty\n", device);
ErrorF("%s is not a tty\n", pi->path);
goto bail;
}
ret = tcgetattr(port, &t);
if(ret < 0) {
ErrorF("Couldn't tcgetattr(%s): %d\n", device, errno);
ErrorF("Couldn't tcgetattr(%s): %d\n", pi->path, errno);
goto bail;
}
t.c_iflag &= ~ (IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
@ -140,24 +149,36 @@ MsInit (void)
t.c_cc[VTIME] = 0;
ret = tcsetattr(port, TCSANOW, &t);
if(ret < 0) {
ErrorF("Couldn't tcsetattr(%s): %d\n", device, errno);
ErrorF("Couldn't tcsetattr(%s): %d\n", pi->path, errno);
goto bail;
}
if (KdRegisterFd (MsInputType, port, MsRead, (void *) 0))
return 1;
if (KdRegisterFd (port, MsRead, pi))
return TRUE;
pi->driverPrivate = (void *)port;
return Success;
bail:
close(port);
return 0;
return BadMatch;
}
static void
MsFini (void)
MsDisable (KdPointerInfo *pi)
{
KdUnregisterFds (MsInputType, TRUE);
KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
}
KdMouseFuncs MsMouseFuncs = {
static void
MsFini (KdPointerInfo *pi)
{
}
KdPointerDriver MsMouseDriver = {
"ms",
MsInit,
MsFini
MsEnable,
MsDisable,
MsFini,
NULL,
};

82
hw/kdrive/linux/ps2.c
View File

@ -112,42 +112,78 @@ Ps2Read (int ps2Port, void *closure)
dy = -dy;
n -= 3;
b += 3;
KdEnqueueMouseEvent (kdMouseInfo, flags, dx, dy);
KdEnqueuePointerEvent (closure, flags, dx, dy, 0);
}
}
}
int Ps2InputType;
static int
Ps2Init (void)
static Status
Ps2Init (KdPointerInfo *pi)
{
int i;
int ps2Port;
int n;
int ps2Port, i;
if (!Ps2InputType)
Ps2InputType = KdAllocInputType ();
n = 0;
for (i = 0; i < NUM_PS2_NAMES; i++)
{
ps2Port = open (Ps2Names[i], 0);
if (ps2Port >= 0)
{
if (KdRegisterFd (Ps2InputType, ps2Port, Ps2Read, (void *) i))
n++;
if (!pi->path) {
for (i = 0; i < NUM_PS2_NAMES; i++) {
ps2Port = open (Ps2Names[i], 0);
if (ps2Port >= 0) {
pi->path = KdSaveString (Ps2Names[i]);
break;
}
}
}
return n;
else {
ps2Port = open (pi->path, 0);
}
if (ps2Port < 0)
return BadMatch;
close(ps2Port);
if (!pi->name)
pi->name = KdSaveString ("PS/2 Mouse");
return Success;
}
static Status
Ps2Enable (KdPointerInfo *pi)
{
int fd;
if (!pi)
return BadImplementation;
fd = open (pi->path, 0);
if (fd < 0)
return BadMatch;
if (!KdRegisterFd (fd, Ps2Read, pi)) {
close(fd);
return BadAlloc;
}
pi->driverPrivate = (void *)fd;
return Success;
}
static void
Ps2Disable (KdPointerInfo *pi)
{
KdUnregisterFd (pi, (int)pi->driverPrivate, TRUE);
}
static void
Ps2Fini (void)
Ps2Fini (KdPointerInfo *pi)
{
KdUnregisterFds (Ps2InputType, TRUE);
}
KdMouseFuncs Ps2MouseFuncs = {
KdPointerDriver Ps2MouseDriver = {
"ps2",
Ps2Init,
Ps2Fini
Ps2Enable,
Ps2Disable,
Ps2Fini,
NULL,
};

144
hw/kdrive/linux/ts.c
View File

@ -75,7 +75,7 @@ TsReadBytes (int fd, char *buf, int len, int min)
static void
TsRead (int tsPort, void *closure)
{
KdMouseInfo *mi = closure;
KdPointerInfo *pi = closure;
TS_EVENT event;
int n;
long x, y;
@ -117,7 +117,7 @@ TsRead (int tsPort, void *closure)
lastx = 0;
lasty = 0;
}
KdEnqueueMouseEvent (mi, flags, x, y);
KdEnqueuePointerEvent (pi, flags, x, y, 0);
}
}
@ -129,95 +129,83 @@ char *TsNames[] = {
#define NUM_TS_NAMES (sizeof (TsNames) / sizeof (TsNames[0]))
int TsInputType;
static int
TsEnable (int fd, void *closure)
{
KdMouseInfo *mi = (KdMouseInfo *)closure;
return open (mi->name, 0);
}
static void
TsDisable (int fd, void *closure)
{
close (fd);
}
static int
TsInit (void)
static Status
TsInit (KdPointerInfo *pi)
{
int i;
int fd;
KdMouseInfo *mi, *next;
int n = 0;
if (!TsInputType)
TsInputType = KdAllocInputType ();
for (mi = kdMouseInfo; mi; mi = next)
{
next = mi->next;
if (mi->inputType)
continue;
if (!mi->name)
{
for (i = 0; i < NUM_TS_NAMES; i++)
{
fd = open (TsNames[i], 0);
if (fd >= 0)
{
mi->name = KdSaveString (TsNames[i]);
break;
}
}
}
else
fd = open (mi->name, 0);
if (fd >= 0)
{
struct h3600_ts_calibration cal;
/*
* Check to see if this is a touch screen
*/
if (ioctl (fd, TS_GET_CAL, &cal) != -1)
{
mi->driver = (void *) fd;
mi->inputType = TsInputType;
if (KdRegisterFd (TsInputType, fd, TsRead, (void *) mi))
{
/* Set callbacks for vt switches etc */
KdRegisterFdEnableDisable (fd, TsEnable, TsDisable);
n++;
}
}
else
close (fd);
if (!pi->path || strcmp(pi->path, "auto") == 0) {
for (i = 0; i < NUM_TS_NAMES; i++) {
fd = open (TsNames[i], 0);
if (fd >= 0) {
pi->path = KdSaveString (TsNames[i]);
break;
}
}
}
else {
fd = open (pi->path, 0);
}
return 0;
if (fd < 0) {
ErrorF("TsInit: Couldn't open %s\n", pi->path);
return BadMatch;
}
close(fd);
pi->name = KdSaveString("H3600 Touchscreen");
return Success;
}
static Status
TsEnable (KdPointerInfo *pi)
{
int fd;
if (!pi || !pi->path)
return BadImplementation;
fd = open(pi->path, 0);
if (fd < 0) {
ErrorF("TsInit: Couldn't open %s\n", pi->path);
return BadMatch;
}
struct h3600_ts_calibration cal;
/*
* Check to see if this is a touch screen
*/
if (ioctl (fd, TS_GET_CAL, &cal) != -1) {
mi->driverPrivate = (void *) fd;
if (!KdRegisterFd (fd, TsRead, (void *) mi)) {
close(fd);
return BadAlloc;
}
}
else {
ErrorF("TsEnable: %s is not a touchscreen\n", pi->path);
close (fd);
return BadMatch;
}
return Success;
}
static void
TsFini (void)
TsFini (KdPointerInfo *pi)
{
KdMouseInfo *mi;
KdUnregisterFds (TsInputType, TRUE);
for (mi = kdMouseInfo; mi; mi = mi->next)
{
if (mi->inputType == TsInputType)
{
mi->driver = 0;
mi->inputType = 0;
}
}
KdUnregisterFds (pi, (int)pi->driverPrivate, TRUE);
mi->driverPrivate = NULL;
}
KdMouseFuncs TsFuncs = {
KdPointerDriver TsDriver = {
TsInit,
TsFini
TsEnable,
TsDisable,
TsFini,
NULL,
};

375
hw/kdrive/linux/tslib.c
View File

@ -1,6 +1,6 @@
/*
* $RCSId: xc/programs/Xserver/hw/kdrive/linux/tslib.c,v 1.1 2002/11/01 22:27:49 keithp Exp $
* TSLIB based touchscreen driver for TinyX
* TSLIB based touchscreen driver for KDrive
* Porting to new input API and event queueing by Daniel Stone.
* Derived from ts.c by Keith Packard
* Derived from ps2.c by Jim Gettys
*
@ -8,66 +8,33 @@
* Copyright © 2000 Compaq Computer Corporation
* Copyright © 2002 MontaVista Software Inc.
* Copyright © 2005 OpenedHand Ltd.
* Copyright © 2006 Nokia Corporation
*
* 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 of Keith Packard or Compaq not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Keith Packard and Compaq makes no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
* documentation, and that the name of the authors and/or copyright holders
* not be used in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission. The authors and/or
* copyright holders make no representations about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*
* KEITH PACKARD AND COMPAQ DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
* IN NO EVENT SHALL KEITH PACKARD 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.
*
* 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 of Michael Taht or MontaVista not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Michael Taht and Montavista make no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* MICHAEL TAHT AND MONTAVISTA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
* IN NO EVENT SHALL EITHER 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.
*
* 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 of Matthew Allum or OpenedHand not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Matthew Allum and OpenedHand make no
* representations about the suitability of this software for any purpose. It
* is provided "as is" without express or implied warranty.
*
* MATTHEW ALLUM AND OPENEDHAND DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
* IN NO EVENT SHALL EITHER 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.
* THE AUTHORS AND/OR COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD
* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS, IN NO EVENT SHALL THE AUTHORS AND/OR COPYRIGHT HOLDERS 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.
*/
#ifdef HAVE_CONFIG_H
#ifdef HAVE_KDRIVE_CONFIG_H
#include <kdrive-config.h>
#endif
#define NEED_EVENTS
#include <X11/X.h>
#include <X11/Xproto.h>
@ -77,186 +44,158 @@
#include "kdrive.h"
#include <sys/ioctl.h>
#include <tslib.h>
#include <dirent.h>
#include <linux/input.h>
static struct tsdev *tsDev = NULL;
static char *TsNames[] = {
NULL, /* set via TSLIB_TSDEVICE */
"/dev/ts",
"/dev/touchscreen/0",
struct TslibPrivate {
int fd;
int lastx, lasty;
struct tsdev *tsDev;
void (*raw_event_hook)(int x, int y, int pressure, void *closure);
void *raw_event_closure;
int phys_screen;
};
#define NUM_TS_NAMES (sizeof (TsNames) / sizeof (TsNames[0]))
/* For XCalibrate extension */
void (*tslib_raw_event_hook)(int x, int y, int pressure, void *closure);
void *tslib_raw_event_closure;
int TsInputType = 0;
int KdTsPhyScreen = 0; /* XXX Togo .. */
static void
TsRead (int tsPort, void *closure)
TsRead (int fd, void *closure)
{
KdMouseInfo *mi = closure;
struct ts_sample event;
long x, y;
unsigned long flags;
KdPointerInfo *pi = closure;
struct TslibPrivate *private = pi->driverPrivate;
struct ts_sample event;
long x = 0, y = 0;
unsigned long flags;
if (tslib_raw_event_hook)
{
/* XCalibrate Ext */
if (ts_read_raw(tsDev, &event, 1) == 1)
{
tslib_raw_event_hook (event.x,
event.y,
event.pressure,
tslib_raw_event_closure);
}
return;
}
while (ts_read(tsDev, &event, 1) == 1)
{
flags = (event.pressure) ? KD_BUTTON_1 : 0;
x = event.x;
y = event.y;
KdEnqueueMouseEvent (mi, flags, x, y);
}
}
static int
TsLibOpen(char *dev)
{
if(!(tsDev = ts_open(dev, 0)))
return -1;
if (ts_config(tsDev))
return -1;
return ts_fd(tsDev);
}
static int
TslibEnable (int not_needed_fd, void *closure)
{
KdMouseInfo *mi = closure;
int fd = 0;
if ((fd = TsLibOpen(mi->name)) == -1)
ErrorF ("Unable to re-enable TSLib ( on %s )", mi->name);
return fd;
}
static void
TslibDisable (int fd, void *closure)
{
if (tsDev)
ts_close(tsDev);
tsDev = NULL;
}
static int
TslibInit (void)
{
int i, j = 0;
KdMouseInfo *mi, *next;
int fd = 0;
int req_type;
if (!TsInputType)
{
TsInputType = KdAllocInputType ();
KdParseMouse(0); /* allocate safe slot in kdMouseInfo */
req_type = 0;
if (private->raw_event_hook) {
while (ts_read_raw(private->tsDev, &event, 1) == 1)
private->raw_event_hook (event.x, event.y, event.pressure,
private->raw_event_closure);
return;
}
else req_type = TsInputType; /* is being re-inited */
for (mi = kdMouseInfo; mi; mi = next)
{
next = mi->next;
/* find a usuable slot */
if (mi->inputType != req_type)
continue;
/* Check for tslib env var device setting */
if ((TsNames[0] = getenv("TSLIB_TSDEVICE")) == NULL)
j++;
if (!mi->name)
{
for (i = j; i < NUM_TS_NAMES; i++)
{
fd = TsLibOpen(TsNames[i]);
if (fd >= 0)
{
mi->name = KdSaveString (TsNames[i]);
break;
}
}
}
else
fd = TsLibOpen(mi->name);
if (fd >= 0 && tsDev != NULL)
{
mi->driver = (void *) fd;
mi->inputType = TsInputType;
KdRegisterFd (TsInputType, fd, TsRead, (void *) mi);
/* Set callbacks for vt switches etc */
KdRegisterFdEnableDisable (fd, TslibEnable, TslibDisable);
return TRUE;
}
}
ErrorF ("Failed to open TSLib device, tried ");
for (i = j; i < NUM_TS_NAMES; i++)
ErrorF ("%s ", TsNames[i]);
ErrorF (".\n");
if (!TsNames[0])
ErrorF ("Try setting TSLIB_TSDEVICE to valid /dev entry?\n");
if (fd > 0)
close(fd);
return FALSE;
}
static void
TslibFini (void)
{
KdMouseInfo *mi;
while (ts_read(private->tsDev, &event, 1) == 1) {
if (event.pressure) {
if (event.pressure > pi->dixdev->absolute->button_threshold)
flags = KD_BUTTON_8;
else
flags = KD_BUTTON_1;
KdUnregisterFds (TsInputType, TRUE);
for (mi = kdMouseInfo; mi; mi = mi->next)
{
if (mi->inputType == TsInputType)
{
if(mi->driver)
{
ts_close(tsDev);
tsDev = NULL;
}
mi->driver = 0;
/*
* Here we test for the touch screen driver actually being on the
* touch screen, if it is we send absolute coordinates. If not,
* then we send delta's so that we can track the entire vga screen.
*/
if (KdCurScreen == private->phys_screen) {
x = event.x;
y = event.y;
} else {
flags |= KD_MOUSE_DELTA;
if ((private->lastx == 0) || (private->lasty == 0)) {
x = event.x;
y = event.y;
} else {
x = event.x - private->lastx;
y = event.y - private->lasty;
}
}
private->lastx = x;
private->lasty = y;
} else {
flags = 0;
x = private->lastx;
y = private->lasty;
}
/* If below is set to 0, then MouseInit() will trash it,
* setting to 'mouse type' ( via server reset). Therefore
* Leave it alone and work around in TslibInit() ( see
* req_type ).
*/
/* mi->inputType = 0; */
}
KdEnqueuePointerEvent (pi, flags, x, y, event.pressure);
}
}
KdMouseFuncs TsFuncs = {
static Status
TslibEnable (KdPointerInfo *pi)
{
struct TslibPrivate *private = pi->driverPrivate;
private->holdThumbEvents = 1;
private->raw_event_hook = NULL;
private->raw_event_closure = NULL;
private->tsDev = ts_open(pi->path, 0);
private->fd = ts_fd(private->tsDev);
if (!private->tsDev || ts_config(private->tsDev) || private->fd < 0) {
ErrorF("[tslib/TslibEnable] failed to open %s\n", pi->path);
if (private->fd > 0);
close(private->fd);
return BadAlloc;
}
if (pi->dixdev && pi->dixdev->absolute &&
pi->dixdev->absolute->button_threshold == 0)
pi->dixdev->absolute->button_threshold = 115;
KdRegisterFd(private->fd, TsRead, pi);
return Success;
}
static void
TslibDisable (KdPointerInfo *pi)
{
struct TslibPrivate *private = pi->driverPrivate;
if (private->fd) {
KdUnregisterFd(pi, private->fd);
close(private->fd);
}
if (private->tsDev)
ts_close(private->tsDev);
private->fd = 0;
private->tsDev = NULL;
}
static Status
TslibInit (KdPointerInfo *pi)
{
int fd = 0, i = 0;
char devpath[PATH_MAX], devname[TS_NAME_SIZE];
DIR *inputdir = NULL;
struct dirent *inputent = NULL;
struct tsdev *tsDev = NULL;
struct TslibPrivate *private = NULL;
if (!pi || !pi->dixdev)
return !Success;
pi->driverPrivate = (struct TslibPrivate *)
xcalloc(sizeof(struct TslibPrivate), 1);
if (!pi->driverPrivate)
return !Success;
private = pi->driverPrivate;
/* hacktastic */
private->phys_screen = 0;
pi->nAxes = 3;
pi->name = KdSaveString("Touchscreen");
pi->inputClass = KD_TOUCHSCREEN;
return Success;
}
static void
TslibFini (KdPointerInfo *pi)
{
if (pi->driverPrivate) {
xfree(pi->driverPrivate);
pi->driverPrivate = NULL;
}
}
KdPointerDriver TsDriver = {
"tslib",
TslibInit,
TslibFini
TslibEnable,
TslibDisable,
TslibFini,
NULL,
};

6
hw/kdrive/mach64/Makefile.am
View File

@ -30,8 +30,4 @@ MACH64_LIBS = \
Xmach64_LDADD = \
$(MACH64_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
Xmach64_DEPENDENCIES = $(MACH64_LIBS)
@XSERVER_LIBS@

3
hw/kdrive/mach64/mach64stub.c
View File

@ -56,7 +56,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

11
hw/kdrive/mga/Makefile.am
View File

@ -7,10 +7,6 @@ bin_PROGRAMS = Xmga
noinst_LIBRARIES = libmga.a
if TSLIB
TSLIB_FLAG = -lts
endif
libmga_a_SOURCES = \
mgadraw.c \
g400_composite.c \
@ -29,9 +25,4 @@ MGA_LIBS = \
Xmga_LDADD = \
$(MGA_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG)
Xmga_DEPENDENCIES = \
libmga.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a
@XSERVER_LIBS@

3
hw/kdrive/mga/mgastub.c
View File

@ -45,7 +45,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

6
hw/kdrive/neomagic/Makefile.am
View File

@ -38,9 +38,3 @@ Xneomagic_LDADD = \
$(NEOMAGIC_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xneomagic_DEPENDENCIES = \
libneomagic.a \
${FBDEV_LIBS} \
${VESA_LIBS}

8
hw/kdrive/neomagic/neomagic.h
View File

@ -26,14 +26,10 @@
#include <backend.h>
#include "kxv.h"
#include "klinux.h"
#include "vesa.h"
#define DEBUG
#ifdef DEBUG
#define DBGOUT(fmt,a...) fprintf (stderr, fmt, ##a)
#else
#define DBGOUT(fmt,a...)
#endif
#define DBGOUT DebugF
#define ENTER() DBGOUT("Enter %s\n", __FUNCTION__)
#define LEAVE() DBGOUT("Leave %s\n", __FUNCTION__)

6
hw/kdrive/neomagic/neomagicstub.c
View File

@ -51,10 +51,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
#ifdef TOUCHSCREEN
KdAddMouseDriver (&TsFuncs);
#endif
KdOsAddInputDrivers ();
KdInitInput ();
}
void

8
hw/kdrive/nvidia/Makefile.am
View File

@ -7,10 +7,6 @@ bin_PROGRAMS = Xnvidia
noinst_LIBRARIES = libnvidia.a
if TSLIB
TSLIB_FLAG = -lts
endif
# nvidiavideo.c
libnvidia_a_SOURCES = \
@ -31,7 +27,3 @@ Xnvidia_LDADD = \
$(NVIDIA_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xnvidia_DEPENDENCIES = \
libnvidia.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

3
hw/kdrive/nvidia/nvidiastub.c
View File

@ -45,7 +45,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

3
hw/kdrive/pcmcia/pcmciastub.c
View File

@ -45,7 +45,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
extern pcmciaDisplayModeRec pcmciaDefaultModes[];

5
hw/kdrive/pm2/Makefile.am
View File

@ -25,8 +25,3 @@ Xpm2_LDADD = \
$(PM2_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xpm2_DEPENDENCIES = \
libpm2.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

3
hw/kdrive/pm2/pm2stub.c
View File

@ -32,7 +32,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

5
hw/kdrive/r128/Makefile.am
View File

@ -24,8 +24,3 @@ Xr128_LDADD = \
$(R128_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xr128_DEPENDENCIES = \
libr128.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

3
hw/kdrive/r128/r128stub.c
View File

@ -48,7 +48,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

8
hw/kdrive/savage/s3stub.c
View File

@ -60,12 +60,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
#ifdef VXWORKS
KdInitInput (&VxWorksMouseFuncs, &VxWorksKeyboardFuncs);
#endif
#ifdef linux
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
#endif
KdOsAddInputDrivers ();
KdInitInput ();
}
extern int s3CpuTimeout;

5
hw/kdrive/sdl/Makefile.am
View File

@ -5,14 +5,9 @@ INCLUDES = \
bin_PROGRAMS = Xsdl
if TSLIB
TSLIB_FLAG = -lts
endif
Xsdl_SOURCES = sdl.c
Xsdl_LDADD = @KDRIVE_PURE_LIBS@ \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@ \
$(TSLIB_FLAG) \
@XSDL_LIBS@

6
hw/kdrive/sis300/Makefile.am
View File

@ -17,10 +17,6 @@ INCLUDES = \
bin_PROGRAMS = Xsis
if TSLIB
TSLIB_FLAG = -lts
endif
noinst_LIBRARIES = libsis.a
libsis_a_SOURCES = \
@ -42,5 +38,3 @@ Xsis_LDADD = \
$(SIS_LIBS) \
@KDRIVE_LIBS@ \
$(TSLIB_FLAG)
Xsis_DEPENDENCIES = $(SIS_LIBS)

3
hw/kdrive/sis300/sis_stub.c
View File

@ -53,7 +53,8 @@ InitOutput(ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput(int argc, char **argv)
{
KdInitInput(&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers();
KdInitInput();
}
void

3
hw/kdrive/sis530/sisstub.c
View File

@ -53,7 +53,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

6
hw/kdrive/smi/Makefile.am
View File

@ -29,9 +29,3 @@ Xsmi_LDADD = \
$(SMI_LIBS) \
@KDRIVE_LIBS@ \
@XSERVER_LIBS@
Xsmi_DEPENDENCIES = \
libsmi.a \
$(top_builddir)/hw/kdrive/fbdev/libfbdev.a \
$(top_builddir)/hw/kdrive/vesa/libvesa.a

3
hw/kdrive/smi/smistub.c
View File

@ -47,7 +47,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

3
hw/kdrive/src/Makefile.am
View File

@ -24,7 +24,7 @@ libkdrive_a_SOURCES = \
kdrive.h \
kinfo.c \
kinput.c \
kkeymap.h \
kkeymap.c \
kmap.c \
kmode.c \
knoop.c \
@ -37,5 +37,4 @@ libkdrive_a_SOURCES = \
$(top_srcdir)/mi/miinitext.c
libkdrivestubs_a_SOURCES = \
$(top_srcdir)/Xi/stubs.c \
$(top_srcdir)/fb/fbcmap.c

190
hw/kdrive/src/kdrive.c
View File

@ -43,6 +43,12 @@
#include "dpmsproc.h"
#endif
#ifdef HAVE_EXECINFO_H
#include <execinfo.h>
#endif
#include <signal.h>
typedef struct _kdDepths {
CARD8 depth;
CARD8 bpp;
@ -60,6 +66,8 @@ KdDepths kdDepths[] = {
#define NUM_KD_DEPTHS (sizeof (kdDepths) / sizeof (kdDepths[0]))
#define KD_DEFAULT_BUTTONS 5
int kdScreenPrivateIndex;
unsigned long kdGeneration;
@ -76,6 +84,8 @@ Bool kdSwitchPending;
char *kdSwitchCmd;
DDXPointRec kdOrigin;
static Bool kdCaughtSignal = FALSE;
/*
* Carry arguments from InitOutput through driver initialization
* to KdScreenInit
@ -271,7 +281,7 @@ KdSuspend (void)
for (screen = card->screenList; screen; screen = screen->next)
if (screen->mynum == card->selected && screen->pScreen)
KdDisableScreen (screen->pScreen);
if (card->driver)
if (card->driver && card->cfuncs->restore)
(*card->cfuncs->restore) (card);
}
KdDisableInput ();
@ -285,7 +295,8 @@ KdDisableScreens (void)
KdSuspend ();
if (kdEnabled)
{
(*kdOsFuncs->Disable) ();
if (kdOsFuncs->Disable)
(*kdOsFuncs->Disable) ();
kdEnabled = FALSE;
}
}
@ -343,7 +354,8 @@ KdEnableScreens (void)
if (!kdEnabled)
{
kdEnabled = TRUE;
(*kdOsFuncs->Enable) ();
if (kdOsFuncs->Enable)
(*kdOsFuncs->Enable) ();
}
KdResume ();
}
@ -363,11 +375,15 @@ AbortDDX(void)
KdDisableScreens ();
if (kdOsFuncs)
{
if (kdEnabled)
if (kdEnabled && kdOsFuncs->Disable)
(*kdOsFuncs->Disable) ();
(*kdOsFuncs->Fini) ();
if (kdOsFuncs->Fini)
(*kdOsFuncs->Fini) ();
KdDoSwitchCmd ("stop");
}
if (kdCaughtSignal)
abort();
}
void
@ -379,7 +395,7 @@ ddxGiveUp ()
Bool kdDumbDriver;
Bool kdSoftCursor;
static char *
char *
KdParseFindNext (char *cur, char *delim, char *save, char *last)
{
while (*cur && !strchr (delim, *cur))
@ -560,97 +576,6 @@ KdSaveString (char *str)
return n;
}
/*
* Parse mouse information. Syntax:
*
* <device>,<nbutton>,<protocol>{,<option>}...
*
* options: {nmo} pointer mapping (e.g. {321})
* 2button emulate middle button
* 3button dont emulate middle button
*/
void
KdParseMouse (char *arg)
{
char save[1024];
char delim;
KdMouseInfo *mi;
int i;
mi = KdMouseInfoAdd ();
if (!mi)
return;
mi->name = 0;
mi->prot = 0;
mi->emulateMiddleButton = kdEmulateMiddleButton;
mi->transformCoordinates = !kdRawPointerCoordinates;
mi->nbutton = 3;
for (i = 0; i < KD_MAX_BUTTON; i++)
mi->map[i] = i + 1;
if (!arg)
return;
if (strlen (arg) >= sizeof (save))
return;
arg = KdParseFindNext (arg, ",", save, &delim);
if (!save[0])
return;
mi->name = KdSaveString (save);
if (delim != ',')
return;
arg = KdParseFindNext (arg, ",", save, &delim);
if (!save[0])
return;
if ('1' <= save[0] && save[0] <= '0' + KD_MAX_BUTTON && save[1] == '\0')
{
mi->nbutton = save[0] - '0';
if (mi->nbutton > KD_MAX_BUTTON)
{
UseMsg ();
return;
}
}
if (!delim != ',')
return;
arg = KdParseFindNext (arg, ",", save, &delim);
if (save[0])
mi->prot = KdSaveString (save);
while (delim == ',')
{
arg = KdParseFindNext (arg, ",", save, &delim);
if (save[0] == '{')
{
char *s = save + 1;
i = 0;
while (*s && *s != '}')
{
if ('1' <= *s && *s <= '0' + mi->nbutton)
mi->map[i] = *s - '0';
else
UseMsg ();
s++;
}
}
else if (!strcmp (save, "2button"))
mi->emulateMiddleButton = TRUE;
else if (!strcmp (save, "3button"))
mi->emulateMiddleButton = FALSE;
else if (!strcmp (save, "rawcoord"))
mi->transformCoordinates = FALSE;
else if (!strcmp (save, "transform"))
mi->transformCoordinates = TRUE;
else
UseMsg ();
}
}
void
KdParseRgba (char *rgba)
{
@ -736,6 +661,11 @@ KdProcessArgument (int argc, char **argv, int i)
kdDontZap = TRUE;
return 1;
}
if (!strcmp (argv[i], "-nozap"))
{
kdDontZap = TRUE;
return 1;
}
if (!strcmp (argv[i], "-3button"))
{
kdEmulateMiddleButton = FALSE;
@ -785,14 +715,6 @@ KdProcessArgument (int argc, char **argv, int i)
UseMsg ();
return 2;
}
if (!strcmp (argv[i], "-mouse"))
{
if ((i+1) < argc)
KdParseMouse (argv[i+1]);
else
UseMsg ();
return 2;
}
if (!strcmp (argv[i], "-rgba"))
{
if ((i+1) < argc)
@ -814,6 +736,20 @@ KdProcessArgument (int argc, char **argv, int i)
{
return 1;
}
if (!strcmp (argv[i], "-mouse") ||
!strcmp (argv[i], "-pointer")) {
if (i + 1 >= argc)
UseMsg();
KdAddConfigPointer(argv[i + 1]);
return 2;
}
if (!strcmp (argv[i], "-keybd")) {
if (i + 1 >= argc)
UseMsg();
KdAddConfigKeyboard(argv[i + 1]);
return 2;
}
#ifdef PSEUDO8
return p8ProcessArgument (argc, argv, i);
#else
@ -835,7 +771,8 @@ KdOsInit (KdOsFuncs *pOsFuncs)
if (serverGeneration == 1)
{
KdDoSwitchCmd ("start");
(*pOsFuncs->Init) ();
if (pOsFuncs->Init)
(*pOsFuncs->Init) ();
}
}
}
@ -1420,6 +1357,39 @@ KdDepthToFb (ScreenPtr pScreen, int depth)
#endif
#ifdef HAVE_BACKTRACE
/* shamelessly ripped from xf86Events.c */
void
KdBacktrace (int signum)
{
void *array[32]; /* more than 32 and you have bigger problems */
size_t size, i;
char **strings;
signal(signum, SIG_IGN);
size = backtrace (array, 32);
fprintf (stderr, "\nBacktrace (%d deep):\n", size);
strings = backtrace_symbols (array, size);
for (i = 0; i < size; i++)
fprintf (stderr, "%d: %s\n", i, strings[i]);
free (strings);
kdCaughtSignal = TRUE;
if (signum == SIGSEGV)
FatalError("Segmentation fault caught\n");
else if (signum > 0)
FatalError("Signal %d caught\n", signum);
}
#else
void
KdBacktrace (int signum)
{
kdCaughtSignal = TRUE;
FatalError("Segmentation fault caught\n");
}
#endif
void
KdInitOutput (ScreenInfo *pScreenInfo,
int argc,
@ -1427,6 +1397,12 @@ KdInitOutput (ScreenInfo *pScreenInfo,
{
KdCardInfo *card;
KdScreenInfo *screen;
#ifdef COMPOSITE
/* kind of a hack: we want Composite enabled, but it's disabled per
* default. */
noCompositeExtension = FALSE;
#endif
if (!kdCardInfo)
{
@ -1464,6 +1440,8 @@ KdInitOutput (ScreenInfo *pScreenInfo,
for (card = kdCardInfo; card; card = card->next)
for (screen = card->screenList; screen; screen = screen->next)
KdAddScreen (pScreenInfo, screen, argc, argv);
signal(SIGSEGV, KdBacktrace);
}
#ifdef DPMSExtension

246
hw/kdrive/src/kdrive.h
View File

@ -47,6 +47,10 @@
#include "shadow.h"
#include "randrstr.h"
#ifdef XKB
#include <X11/extensions/XKBstr.h>
#endif
extern WindowPtr *WindowTable;
#define KD_DPMS_NORMAL 0
@ -63,6 +67,8 @@ extern WindowPtr *WindowTable;
#define KD_MAX_CARD_ADDRESS 8
#endif
#define Status int
/*
* Configuration information per video card
*/
@ -215,7 +221,7 @@ typedef struct {
#endif
} KdPrivScreenRec, *KdPrivScreenPtr;
typedef enum _kdMouseState {
typedef enum _kdPointerState {
start,
button_1_pend,
button_1_down,
@ -226,51 +232,135 @@ typedef enum _kdMouseState {
synth_2_down_3,
synth_2_down_1,
num_input_states
} KdMouseState;
} KdPointerState;
#define KD_MAX_BUTTON 7
#define KD_MAX_BUTTON 32
typedef struct _KdMouseInfo {
struct _KdMouseInfo *next;
void *driver;
void *closure;
char *name;
char *prot;
char map[KD_MAX_BUTTON];
int nbutton;
Bool emulateMiddleButton;
unsigned long emulationTimeout;
Bool timeoutPending;
KdMouseState mouseState;
Bool eventHeld;
xEvent heldEvent;
unsigned char buttonState;
int emulationDx, emulationDy;
int inputType;
Bool transformCoordinates;
} KdMouseInfo;
#define KD_KEYBOARD 1
#define KD_MOUSE 2
#define KD_TOUCHSCREEN 3
extern KdMouseInfo *kdMouseInfo;
typedef struct _KdPointerInfo KdPointerInfo;
typedef struct _KdPointerDriver {
char *name;
Status (*Init) (KdPointerInfo *);
Status (*Enable) (KdPointerInfo *);
void (*Disable) (KdPointerInfo *);
void (*Fini) (KdPointerInfo *);
struct _KdPointerDriver *next;
} KdPointerDriver;
struct _KdPointerInfo {
DeviceIntPtr dixdev;
char *name;
char *path;
InputOption *options;
int inputClass;
CARD8 map[KD_MAX_BUTTON + 1];
int nButtons;
int nAxes;
Bool emulateMiddleButton;
unsigned long emulationTimeout;
int emulationDx, emulationDy;
Bool timeoutPending;
KdPointerState mouseState;
Bool eventHeld;
struct {
int type;
int x;
int y;
int z;
int flags;
int absrel;
} heldEvent;
unsigned char buttonState;
Bool transformCoordinates;
int pressureThreshold;
KdPointerDriver *driver;
void *driverPrivate;
struct _KdPointerInfo *next;
};
extern int KdCurScreen;
KdMouseInfo *KdMouseInfoAdd (void);
void KdMouseInfoDispose (KdMouseInfo *mi);
void KdParseMouse (char *);
void KdAddPointerDriver (KdPointerDriver *driver);
void KdRemovePointerDriver (KdPointerDriver *driver);
KdPointerInfo *KdNewPointer (void);
void KdFreePointer (KdPointerInfo *);
int KdAddPointer (KdPointerInfo *ki);
int KdAddConfigPointer (char *pointer);
void KdRemovePointer (KdPointerInfo *ki);
typedef struct _KdMouseFuncs {
Bool (*Init) (void);
void (*Fini) (void);
} KdMouseFuncs;
typedef struct _KdKeyboardFuncs {
void (*Load) (void);
int (*Init) (void);
void (*Leds) (int);
void (*Bell) (int, int, int);
void (*Fini) (void);
int LockLed;
} KdKeyboardFuncs;
#define KD_KEY_COUNT 248
#define KD_MIN_KEYCODE 8
#define KD_MAX_KEYCODE 255
#define KD_MAX_WIDTH 4
#define KD_MAX_LENGTH (KD_MAX_KEYCODE - KD_MIN_KEYCODE + 1)
typedef struct {
KeySym modsym;
int modbit;
} KdKeySymModsRec;
extern const KeySym kdDefaultKeymap[KD_MAX_LENGTH * KD_MAX_WIDTH];
extern const int kdDefaultKeymapWidth;
extern const CARD8 kdDefaultModMap[MAP_LENGTH];
extern const KeySymsRec kdDefaultKeySyms;
typedef struct _KdKeyboardInfo KdKeyboardInfo;
typedef struct _KdKeyboardDriver {
char *name;
Bool (*Init) (KdKeyboardInfo *);
Bool (*Enable) (KdKeyboardInfo *);
void (*Leds) (KdKeyboardInfo *, int);
void (*Bell) (KdKeyboardInfo *, int, int, int);
void (*Disable) (KdKeyboardInfo *);
void (*Fini) (KdKeyboardInfo *);
struct _KdKeyboardDriver *next;
} KdKeyboardDriver;
struct _KdKeyboardInfo {
struct _KdKeyboardInfo *next;
DeviceIntPtr dixdev;
void *closure;
char *name;
char *path;
int inputClass;
#ifdef XKB
XkbDescPtr xkb;
#endif
int LockLed;
CARD8 keyState[KD_KEY_COUNT/8];
int minScanCode;
int maxScanCode;
CARD8 modmap[MAP_LENGTH];
KeySymsRec keySyms;
int leds;
int bellPitch;
int bellDuration;
InputOption *options;
KdKeyboardDriver *driver;
void *driverPrivate;
};
void KdAddKeyboardDriver (KdKeyboardDriver *driver);
void KdRemoveKeyboardDriver (KdKeyboardDriver *driver);
KdKeyboardInfo *KdNewKeyboard (void);
void KdFreeKeyboard (KdKeyboardInfo *ki);
int KdAddConfigKeyboard (char *pointer);
int KdAddKeyboard (KdKeyboardInfo *ki);
void KdRemoveKeyboard (KdKeyboardInfo *ki);
typedef struct _KdOsFuncs {
int (*Init) (void);
@ -279,6 +369,7 @@ typedef struct _KdOsFuncs {
void (*Disable) (void);
void (*Fini) (void);
void (*pollEvents) (void);
void (*Bell) (int, int, int);
} KdOsFuncs;
typedef enum _KdSyncPolarity {
@ -307,9 +398,9 @@ typedef struct _KdMonitorTiming {
extern const KdMonitorTiming kdMonitorTimings[];
extern const int kdNumMonitorTimings;
typedef struct _KdMouseMatrix {
typedef struct _KdPointerMatrix {
int matrix[2][3];
} KdMouseMatrix;
} KdPointerMatrix;
typedef struct _KaaTrapezoid {
float tl, tr, ty;
@ -628,8 +719,14 @@ KdParseScreen (KdScreenInfo *screen,
char *
KdSaveString (char *str);
void
KdParseMouse (char *arg);
KdPointerInfo *
KdParsePointer (char *arg);
KdKeyboardInfo *
KdParseKeyboard (char *arg);
char *
KdParseFindNext (char *cur, char *delim, char *save, char *last);
void
KdParseRgba (char *rgba);
@ -643,6 +740,9 @@ KdProcessArgument (int argc, char **argv, int i);
void
KdOsInit (KdOsFuncs *pOsFuncs);
void
KdOsAddInputDrivers (void);
Bool
KdAllocatePrivates (ScreenPtr pScreen);
@ -677,6 +777,9 @@ KdInitOutput (ScreenInfo *pScreenInfo,
void
KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr);
void
KdBacktrace (int signum);
/* kinfo.c */
KdCardInfo *
@ -699,53 +802,54 @@ KdScreenInfoDispose (KdScreenInfo *si);
/* kinput.c */
void
KdInitInput(KdMouseFuncs *, KdKeyboardFuncs *);
KdInitInput(void);
void
KdAddMouseDriver(KdMouseFuncs *);
KdAddPointerDriver(KdPointerDriver *);
int
KdAllocInputType (void);
void
KdAddKeyboardDriver(KdKeyboardDriver *);
Bool
KdRegisterFd (int type, int fd, void (*read) (int fd, void *closure), void *closure);
KdRegisterFd (int fd, void (*read) (int fd, void *closure), void *closure);
void
KdRegisterFdEnableDisable (int fd,
int (*enable) (int fd, void *closure),
void (*disable) (int fd, void *closure));
KdUnregisterFds (void *closure, Bool do_close);
void
KdUnregisterFds (int type, Bool do_close);
KdUnregisterFd (void *closure, int fd, Bool do_close);
void
KdEnqueueKeyboardEvent(unsigned char scan_code,
unsigned char is_up);
KdEnqueueKeyboardEvent(KdKeyboardInfo *ki, unsigned char scan_code,
unsigned char is_up);
#define KD_BUTTON_1 0x01
#define KD_BUTTON_2 0x02
#define KD_BUTTON_3 0x04
#define KD_BUTTON_4 0x08
#define KD_BUTTON_5 0x10
#define KD_BUTTON_8 0x80
#define KD_MOUSE_DELTA 0x80000000
void
KdEnqueueMouseEvent(KdMouseInfo *mi, unsigned long flags, int x, int y);
KdEnqueuePointerEvent(KdPointerInfo *pi, unsigned long flags, int rx, int ry,
int rz);
void
KdEnqueueMotionEvent (KdMouseInfo *mi, int x, int y);
_KdEnqueuePointerEvent(KdPointerInfo *pi, int type, int x, int y, int z,
int b, int absrel, Bool force);
void
KdReleaseAllKeys (void);
void
KdSetLed (int led, Bool on);
KdSetLed (KdKeyboardInfo *ki, int led, Bool on);
void
KdSetMouseMatrix (KdMouseMatrix *matrix);
KdSetPointerMatrix (KdPointerMatrix *pointer);
void
KdComputeMouseMatrix (KdMouseMatrix *matrix, Rotation randr, int width, int height);
KdComputePointerMatrix (KdPointerMatrix *pointer, Rotation randr, int width, int height);
void
KdBlockHandler (int screen,
@ -768,19 +872,23 @@ KdEnableInput (void);
void
ProcessInputEvents (void);
extern KdMouseFuncs LinuxMouseFuncs;
extern KdMouseFuncs LinuxEvdevFuncs;
extern KdMouseFuncs Ps2MouseFuncs;
extern KdMouseFuncs BusMouseFuncs;
extern KdMouseFuncs MsMouseFuncs;
#ifdef TOUCHSCREEN
extern KdMouseFuncs TsFuncs;
#endif
extern KdKeyboardFuncs LinuxKeyboardFuncs;
void
KdRingBell (KdKeyboardInfo *ki,
int volume,
int pitch,
int duration);
extern KdPointerDriver LinuxMouseDriver;
extern KdPointerDriver LinuxEvdevDriver;
extern KdPointerDriver Ps2MouseDriver;
extern KdPointerDriver BusMouseDriver;
extern KdPointerDriver MsMouseDriver;
extern KdPointerDriver TsDriver;
extern KdKeyboardDriver LinuxKeyboardDriver;
extern KdOsFuncs LinuxFuncs;
extern KdMouseFuncs VxWorksMouseFuncs;
extern KdKeyboardFuncs VxWorksKeyboardFuncs;
extern KdPointerDriver VxWorksMouseDriver;
extern KdKeyboardDriver VxWorksKeyboardDriver;
extern KdOsFuncs VxWorksFuncs;
/* kmap.c */

81
hw/kdrive/src/kinfo.c
View File

@ -101,7 +101,7 @@ KdScreenInfoDispose (KdScreenInfo *si)
KdCardInfo *ci = si->card;
KdScreenInfo **prev;
for (prev = &ci->screenList; *prev; prev = &(*prev)->next)
for (prev = &ci->screenList; *prev; prev = &(*prev)->next) {
if (*prev == si)
{
*prev = si->next;
@ -110,38 +110,67 @@ KdScreenInfoDispose (KdScreenInfo *si)
KdCardInfoDispose (ci);
break;
}
}
}
KdMouseInfo *kdMouseInfo;
KdMouseInfo *
KdMouseInfoAdd (void)
KdPointerInfo *
KdNewPointer (void)
{
KdMouseInfo *mi, **prev;
KdPointerInfo *pi;
int i;
mi = (KdMouseInfo *) xalloc (sizeof (KdMouseInfo));
if (!mi)
return 0;
bzero (mi, sizeof (KdMouseInfo));
for (prev = &kdMouseInfo; *prev; prev = &(*prev)->next);
*prev = mi;
return mi;
pi = (KdPointerInfo *)xcalloc(1, sizeof(KdPointerInfo));
if (!pi)
return NULL;
pi->name = KdSaveString("Generic Pointer");
pi->path = NULL;
pi->inputClass = KD_MOUSE;
pi->driver = NULL;
pi->driverPrivate = NULL;
pi->next = NULL;
pi->options = NULL;
pi->nAxes = 3;
pi->nButtons = KD_MAX_BUTTON;
for (i = 1; i < KD_MAX_BUTTON; i++)
pi->map[i] = i;
return pi;
}
void
KdMouseInfoDispose (KdMouseInfo *mi)
KdFreePointer(KdPointerInfo *pi)
{
KdMouseInfo **prev;
InputOption *option, *prev = NULL;
for (prev = &kdMouseInfo; *prev; prev = &(*prev)->next)
if (*prev == mi)
{
*prev = mi->next;
if (mi->name)
xfree (mi->name);
if (mi->prot)
xfree (mi->prot);
xfree (mi);
break;
}
if (pi->name)
xfree(pi->name);
if (pi->path)
xfree(pi->path);
for (option = pi->options; option; option = option->next) {
if (prev)
xfree(prev);
if (option->key)
xfree(option->key);
if (option->value)
xfree(option->value);
prev = option;
}
if (prev)
xfree(prev);
xfree(pi);
}
void
KdFreeKeyboard(KdKeyboardInfo *ki)
{
if (ki->name)
xfree(ki->name);
if (ki->path)
xfree(ki->path);
ki->next = NULL;
xfree(ki);
}

1843
hw/kdrive/src/kinput.c
View File

File diff suppressed because it is too large Load Diff

66
hw/kdrive/src/kkeymap.c
View File

@ -28,14 +28,13 @@
#endif
#include "kdrive.h"
#include <X11/keysym.h>
#include "kkeymap.h"
/*
* Map scan codes (both regular and synthesized from extended keys)
* to X keysyms
*/
KeySym kdKeymap[(MAX_SCANCODE - MIN_SCANCODE + 1) * MAX_WIDTH] = {
const KeySym kdDefaultKeymap[KD_MAX_LENGTH * KD_MAX_WIDTH] = {
/* These are directly mapped from DOS scanset 0 */
/* 1 8 */ XK_Escape, NoSymbol,
/* 2 9 */ XK_1, XK_exclam,
@ -152,58 +151,13 @@ KeySym kdKeymap[(MAX_SCANCODE - MIN_SCANCODE + 1) * MAX_WIDTH] = {
/* 110 117 */ NoSymbol, NoSymbol,
/* 111 118 */ NoSymbol, NoSymbol,
/* 112 119 */ NoSymbol, NoSymbol,
;
/*
* Map extended keys to additional scancodes
*/
KdExtendMap kdExtendMap[] = {
0x1d, 89, /* Control_R */
0x1c, 90, /* KP_Enter */
0x35, 91, /* KP_Divide */
0x37, 92, /* Sys_Req */
0x38, 93, /* Alt_R */
0x45, 94, /* Num_Lock */
0x47, 95, /* Home */
0x48, 96, /* Up */
0x49, 97, /* Page_Up */
0x4b, 98, /* Left */
0x4d, 99, /* Right */
0x4f, 100, /* End */
0x50, 101, /* Down */
0x51, 102, /* Page_Down */
0x52, 103, /* Insert */
0x53, 104, /* Delete */
0x5b, 105, /* Super_L (Windows_L) */
0x5c, 106, /* Super_R (Windows_R) */
0x5d, 107, /* Menu */
0x46, 69, /* Break (with control pressed) */
};
#define NUM_EXTEND (sizeof (kdExtendMap)/ sizeof (kdExtendMap[0]))
int kdNumExtend = NUM_EXTEND;
/*
* Map keys on Japanese keyboard far from zero back to reasonable values
*/
KdExtendMap kdJapanMap[] = {
0x70, 108, /* next to Alt key */
0x73, 109, /* dash/vbar */
0x79, 110, /* right of space bar */
0x7b, 111, /* left of space bar */
0x7d, 112, /* Yen */
};
#define NUM_JAPAN (sizeof (kdJapanMap)/sizeof (kdJapanMap[0]))
int kdNumJapan = NUM_JAPAN;
/*
* List of locking key codes
*/
CARD8 kdLockMap[] = {
CARD8 kdLockMap[] = {
65,
101,
77,
@ -218,7 +172,7 @@ int kdNumLock = NUM_LOCK;
* the KEYMAP_LOCKING_ALTGR flag is set in CEKeymapFlags
*/
CARD8 kdOptionalLockMap[] = {
CARD8 kdOptionalLockMap[] = {
100,
};
@ -226,13 +180,13 @@ CARD8 kdOptionalLockMap[] = {
int kdNumOptionalLock = NUM_OPTIONAL_LOCK;
CARD8 kdModMap[MAP_LENGTH];
const CARD8 kdDefaultModMap[MAP_LENGTH];
unsigned long kdKeymapFlags = 0;
unsigned long kdDefaultKeymapFlags = 0;
KeySymsRec kdKeySyms = {
kdKeymap,
MIN_KEYCODE,
MAX_KEYCODE,
2
const KeySymsRec kdDefaultKeySyms = {
kdDefaultKeymap,
KD_MIN_KEYCODE,
KD_MAX_KEYCODE,
KD_MAX_WIDTH
};

1
hw/kdrive/src/kloadmap.c
View File

@ -27,7 +27,6 @@
#include <kdrive-config.h>
#endif
#include "kdrive.h"
#include "kkeymap.h"
#ifdef WINDOWS
#define KM_BUF 1024

3
hw/kdrive/trident/tridentstub.c
View File

@ -49,7 +49,8 @@ InitOutput (ScreenInfo *pScreenInfo, int argc, char **argv)
void
InitInput (int argc, char **argv)
{
KdInitInput (&LinuxMouseFuncs, &LinuxKeyboardFuncs);
KdOsAddInputDrivers ();
KdInitInput ();
}
void

Some files were not shown because too many files have changed in this diff Show More