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

Update to new XI2 names

Browse Source
This commit is contained in:
Peter Hutterer 2009-05-12 21:33:54 +10:00
parent bbf266cca3
commit 8ff1bff8f4
14 changed files with 100 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
Xi/chdevcur.c
View File

@ -54,25 +54,25 @@
*/
int
SProcXIChangeDeviceCursor(ClientPtr client)
SProcXIChangeCursor(ClientPtr client)
{
char n;
REQUEST(xXIChangeDeviceCursorReq);
REQUEST(xXIChangeCursorReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xXIChangeDeviceCursorReq);
return (ProcXIChangeDeviceCursor(client));
REQUEST_SIZE_MATCH(xXIChangeCursorReq);
return (ProcXIChangeCursor(client));
}
int ProcXIChangeDeviceCursor(ClientPtr client)
int ProcXIChangeCursor(ClientPtr client)
{
int rc;
WindowPtr pWin = NULL;
DeviceIntPtr pDev = NULL;
CursorPtr pCursor = NULL;
REQUEST(xXIChangeDeviceCursorReq);
REQUEST_SIZE_MATCH(xXIChangeDeviceCursorReq);
REQUEST(xXIChangeCursorReq);
REQUEST_SIZE_MATCH(xXIChangeCursorReq);
rc = dixLookupDevice(&pDev, stuff->deviceid, client, DixSetAttrAccess);
if (rc != Success)

4
Xi/chdevcur.h
View File

@ -30,7 +30,7 @@
#ifndef CHDEVCUR_H
#define CHDEVCUR_H 1
int SProcXIChangeDeviceCursor(ClientPtr /* client */);
int ProcXIChangeDeviceCursor(ClientPtr /* client */);
int SProcXIChangeCursor(ClientPtr /* client */);
int ProcXIChangeCursor(ClientPtr /* client */);
#endif /* CHDEVCUR_H */

22
Xi/chdevhier.c
View File

@ -61,7 +61,7 @@ extern DevPrivateKey XTstDevicePrivateKey;
*/
void XISendDeviceHierarchyEvent(int flags[MAXDEVICES])
{
xXIDeviceHierarchyEvent *ev;
xXIHierarchyEvent *ev;
xXIHierarchyInfo *info;
DeviceIntRec dummyDev;
DeviceIntPtr dev;
@ -70,7 +70,7 @@ void XISendDeviceHierarchyEvent(int flags[MAXDEVICES])
if (!flags)
return;
ev = xcalloc(1, sizeof(xXIDeviceHierarchyEvent) +
ev = xcalloc(1, sizeof(xXIHierarchyEvent) +
MAXDEVICES * sizeof(xXIHierarchyInfo));
ev->type = GenericEvent;
ev->extension = IReqCode;
@ -128,29 +128,29 @@ void XISendDeviceHierarchyEvent(int flags[MAXDEVICES])
*
*/
int SProcXIChangeDeviceHierarchy(ClientPtr client)
int SProcXIChangeHierarchy(ClientPtr client)
{
char n;
REQUEST(xXIChangeDeviceHierarchyReq);
REQUEST(xXIChangeHierarchyReq);
swaps(&stuff->length, n);
return (ProcXIChangeDeviceHierarchy(client));
return (ProcXIChangeHierarchy(client));
}
#define SWAPIF(cmd) if (client->swapped) { cmd; }
int
ProcXIChangeDeviceHierarchy(ClientPtr client)
ProcXIChangeHierarchy(ClientPtr client)
{
DeviceIntPtr ptr, keybd, xtstptr, xtstkeybd;
xXIAnyHierarchyChangeInfo *any;
int required_len = sizeof(xXIChangeDeviceHierarchyReq);
int required_len = sizeof(xXIChangeHierarchyReq);
char n;
int rc = Success;
int flags[MAXDEVICES] = {0};
REQUEST(xXIChangeDeviceHierarchyReq);
REQUEST_AT_LEAST_SIZE(xXIChangeDeviceHierarchyReq);
REQUEST(xXIChangeHierarchyReq);
REQUEST_AT_LEAST_SIZE(xXIChangeHierarchyReq);
if (!stuff->num_changes)
return rc;
@ -167,7 +167,7 @@ ProcXIChangeDeviceHierarchy(ClientPtr client)
switch(any->type)
{
case XICreateMasterDevice:
case XICreateMaster:
{
xXICreateMasterInfo* c = (xXICreateMasterInfo*)any;
char* name;
@ -229,7 +229,7 @@ ProcXIChangeDeviceHierarchy(ClientPtr client)
xfree(name);
}
break;
case XIRemoveMasterDevice:
case XIRemoveMaster:
{
xXIRemoveMasterInfo* r = (xXIRemoveMasterInfo*)any;
DeviceIntPtr xtstdevice;

4
Xi/chdevhier.h
View File

@ -36,8 +36,8 @@
#ifndef CHDEVHIER_H
#define CHDEVHIER_H 1
int SProcXIChangeDeviceHierarchy(ClientPtr /* client */);
int ProcXIChangeDeviceHierarchy(ClientPtr /* client */);
int SProcXIChangeHierarchy(ClientPtr /* client */);
int ProcXIChangeHierarchy(ClientPtr /* client */);
void XISendDeviceHierarchyEvent(int flags[]);

36
Xi/extinit.c
View File

@ -235,17 +235,17 @@ static int (*ProcIVector[])(ClientPtr) = {
ProcXDeleteDeviceProperty, /* 38 */
ProcXGetDeviceProperty, /* 39 */
/* XI 2 */
ProcXIQueryDevicePointer, /* 40 */
ProcXIWarpDevicePointer, /* 41 */
ProcXIChangeDeviceCursor, /* 42 */
ProcXIChangeDeviceHierarchy, /* 43 */
ProcXIQueryPointer, /* 40 */
ProcXIWarpPointer, /* 41 */
ProcXIChangeCursor, /* 42 */
ProcXIChangeHierarchy, /* 43 */
ProcXISetClientPointer, /* 44 */
ProcXIGetClientPointer, /* 45 */
ProcXISelectEvent, /* 46 */
ProcXIQueryVersion, /* 47 */
ProcXIQueryDevice, /* 48 */
ProcXISetDeviceFocus, /* 49 */
ProcXIGetDeviceFocus, /* 50 */
ProcXISetFocus, /* 49 */
ProcXIGetFocus, /* 50 */
ProcXIGrabDevice, /* 51 */
ProcXIUngrabDevice, /* 52 */
ProcXIAllowEvents, /* 53 */
@ -299,17 +299,17 @@ static int (*SProcIVector[])(ClientPtr) = {
SProcXChangeDeviceProperty, /* 37 */
SProcXDeleteDeviceProperty, /* 38 */
SProcXGetDeviceProperty, /* 39 */
SProcXIQueryDevicePointer, /* 40 */
SProcXIWarpDevicePointer, /* 41 */
SProcXIChangeDeviceCursor, /* 42 */
SProcXIChangeDeviceHierarchy, /* 43 */
SProcXIQueryPointer, /* 40 */
SProcXIWarpPointer, /* 41 */
SProcXIChangeCursor, /* 42 */
SProcXIChangeHierarchy, /* 43 */
SProcXISetClientPointer, /* 44 */
SProcXIGetClientPointer, /* 45 */
SProcXISelectEvent, /* 46 */
SProcXIQueryVersion, /* 47 */
SProcXIQueryDevice, /* 48 */
SProcXISetDeviceFocus, /* 49 */
SProcXIGetDeviceFocus, /* 50 */
SProcXISetFocus, /* 49 */
SProcXIGetFocus, /* 50 */
SProcXIGrabDevice, /* 51 */
SProcXIUngrabDevice, /* 52 */
SProcXIAllowEvents, /* 53 */
@ -502,9 +502,8 @@ SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
SRepXListDeviceProperties(client, len, (xListDevicePropertiesReply*)rep);
else if (rep->RepType == X_GetDeviceProperty)
SRepXGetDeviceProperty(client, len, (xGetDevicePropertyReply *) rep);
else if (rep->RepType == X_XIQueryDevicePointer)
SRepXIQueryDevicePointer(client, len,
(xXIQueryDevicePointerReply *) rep);
else if (rep->RepType == X_XIQueryPointer)
SRepXIQueryPointer(client, len, (xXIQueryPointerReply *) rep);
else if (rep->RepType == X_XIGetClientPointer)
SRepXIGetClientPointer(client, len, (xXIGetClientPointerReply*) rep);
else if (rep->RepType == X_XIQueryDevice)
@ -763,8 +762,8 @@ static void SDeviceEvent(xXIDeviceEvent *from, xXIDeviceEvent *to)
}
}
static void SDeviceHierarchyEvent(xXIDeviceHierarchyEvent *from,
xXIDeviceHierarchyEvent *to)
static void SDeviceHierarchyEvent(xXIHierarchyEvent *from,
xXIHierarchyEvent *to)
{
int i;
char n;
@ -816,8 +815,7 @@ XI2EventSwap(xGenericEvent *from, xGenericEvent *to)
(xXIDeviceChangedEvent*)to);
break;
case XI_HierarchyChanged:
SDeviceHierarchyEvent((xXIDeviceHierarchyEvent*)from,
(xXIDeviceHierarchyEvent*)to);
SDeviceHierarchyEvent((xXIHierarchyEvent*)from, (xXIHierarchyEvent*)to);
break;
case XI_PropertyEvent:
SXIPropertyEvent((xXIPropertyEvent*)from,

26
Xi/querydp.c
View File

@ -58,26 +58,26 @@
*/
int
SProcXIQueryDevicePointer(ClientPtr client)
SProcXIQueryPointer(ClientPtr client)
{
char n;
REQUEST(xXIQueryDevicePointerReq);
REQUEST(xXIQueryPointerReq);
swaps(&stuff->length, n);
return (ProcXIQueryDevicePointer(client));
return (ProcXIQueryPointer(client));
}
int
ProcXIQueryDevicePointer(ClientPtr client)
ProcXIQueryPointer(ClientPtr client)
{
int rc;
xXIQueryDevicePointerReply rep;
xXIQueryPointerReply rep;
DeviceIntPtr pDev, kbd;
WindowPtr pWin, t;
SpritePtr pSprite;
REQUEST(xXIQueryDevicePointerReq);
REQUEST_SIZE_MATCH(xXIQueryDevicePointerReq);
REQUEST(xXIQueryPointerReq);
REQUEST_SIZE_MATCH(xXIQueryPointerReq);
rc = dixLookupDevice(&pDev, stuff->deviceid, client, DixReadAccess);
if (rc != Success)
@ -92,7 +92,7 @@ ProcXIQueryDevicePointer(ClientPtr client)
rc = dixLookupWindow(&pWin, stuff->win, client, DixReadAccess);
if (rc != Success)
{
SendErrorToClient(client, IReqCode, X_XIQueryDevicePointer,
SendErrorToClient(client, IReqCode, X_XIQueryPointer,
stuff->win, rc);
return Success;
}
@ -104,7 +104,7 @@ ProcXIQueryDevicePointer(ClientPtr client)
pSprite = pDev->spriteInfo->sprite;
rep.repType = X_Reply;
rep.RepType = X_XIQueryDevicePointer;
rep.RepType = X_XIQueryPointer;
rep.length = 0;
rep.sequenceNumber = client->sequence;
rep.mask = pDev->button->state;
@ -146,20 +146,20 @@ ProcXIQueryDevicePointer(ClientPtr client)
}
#endif
WriteReplyToClient(client, sizeof(xXIQueryDevicePointerReply), &rep);
WriteReplyToClient(client, sizeof(xXIQueryPointerReply), &rep);
return Success;
}
/***********************************************************************
*
* This procedure writes the reply for the XIQueryDevicePointer function,
* This procedure writes the reply for the XIQueryPointer function,
* if the client and server have a different byte ordering.
*
*/
void
SRepXIQueryDevicePointer(ClientPtr client, int size,
xXIQueryDevicePointerReply * rep)
SRepXIQueryPointer(ClientPtr client, int size,
xXIQueryPointerReply * rep)
{
char n;

10
Xi/querydp.h
View File

@ -30,10 +30,10 @@
#ifndef QUERYDP_H
#define QUERYDP_H 1
int SProcXIQueryDevicePointer(ClientPtr /* client */);
int ProcXIQueryDevicePointer(ClientPtr /* client */);
void SRepXIQueryDevicePointer(ClientPtr /* client */ ,
int /* size */ ,
xXIQueryDevicePointerReply * /* rep */);
int SProcXIQueryPointer(ClientPtr /* client */);
int ProcXIQueryPointer(ClientPtr /* client */);
void SRepXIQueryPointer(ClientPtr /* client */ ,
int /* size */ ,
xXIQueryPointerReply * /* rep */);
#endif /* QUERYDP_H */

12
Xi/warpdevp.c
View File

@ -54,17 +54,17 @@
*/
int
SProcXIWarpDevicePointer(ClientPtr client)
SProcXIWarpPointer(ClientPtr client)
{
char n;
REQUEST(xXIWarpDevicePointerReq);
REQUEST(xXIWarpPointerReq);
swaps(&stuff->length, n);
return (ProcXIWarpDevicePointer(client));
return (ProcXIWarpPointer(client));
}
int
ProcXIWarpDevicePointer(ClientPtr client)
ProcXIWarpPointer(ClientPtr client)
{
int rc;
int x, y;
@ -73,8 +73,8 @@ ProcXIWarpDevicePointer(ClientPtr client)
SpritePtr pSprite;
ScreenPtr newScreen;
REQUEST(xXIWarpDevicePointerReq);
REQUEST_SIZE_MATCH(xXIWarpDevicePointerReq);
REQUEST(xXIWarpPointerReq);
REQUEST_SIZE_MATCH(xXIWarpPointerReq);
/* FIXME: panoramix stuff is missing, look at ProcWarpPointer */

4
Xi/warpdevp.h
View File

@ -30,7 +30,7 @@
#ifndef WARPDEVP_H
#define WARPDEVP_H 1
int SProcXIWarpDevicePointer(ClientPtr /* client */);
int ProcXIWarpDevicePointer(ClientPtr /* client */);
int SProcXIWarpPointer(ClientPtr /* client */);
int ProcXIWarpPointer(ClientPtr /* client */);
#endif /* WARPDEVP_H */

16
Xi/xiselectev.c
View File

@ -41,7 +41,7 @@ SProcXISelectEvent(ClientPtr client)
{
char n;
int i;
xXIDeviceEventMask* evmask;
xXIEventMask* evmask;
REQUEST(xXISelectEventsReq);
swaps(&stuff->length, n);
@ -49,12 +49,12 @@ SProcXISelectEvent(ClientPtr client)
swapl(&stuff->window, n);
swaps(&stuff->num_masks, n);
evmask = (xXIDeviceEventMask*)&stuff[1];
evmask = (xXIEventMask*)&stuff[1];
for (i = 0; i < stuff->num_masks; i++)
{
swaps(&evmask->deviceid, n);
swaps(&evmask->mask_len, n);
evmask = (xXIDeviceEventMask*)(((char*)evmask) + evmask->mask_len * 4);
evmask = (xXIEventMask*)(((char*)evmask) + evmask->mask_len * 4);
}
return (ProcXISelectEvent(client));
@ -67,7 +67,7 @@ ProcXISelectEvent(ClientPtr client)
WindowPtr win;
DeviceIntPtr dev;
DeviceIntRec dummy;
xXIDeviceEventMask *evmask;
xXIEventMask *evmask;
int *types = NULL;
REQUEST(xXISelectEventsReq);
@ -78,7 +78,7 @@ ProcXISelectEvent(ClientPtr client)
return rc;
/* check request validity */
evmask = (xXIDeviceEventMask*)&stuff[1];
evmask = (xXIEventMask*)&stuff[1];
num_masks = stuff->num_masks;
while(num_masks--)
{
@ -102,11 +102,11 @@ ProcXISelectEvent(ClientPtr client)
}
}
evmask = (xXIDeviceEventMask*)(((unsigned char*)evmask) + evmask->mask_len * 4);
evmask = (xXIEventMask*)(((unsigned char*)evmask) + evmask->mask_len * 4);
}
/* Set masks on window */
evmask = (xXIDeviceEventMask*)&stuff[1];
evmask = (xXIEventMask*)&stuff[1];
num_masks = stuff->num_masks;
while(num_masks--)
{
@ -118,7 +118,7 @@ ProcXISelectEvent(ClientPtr client)
} else
dixLookupDevice(&dev, evmask->deviceid, client, DixReadAccess);
XISetEventMask(dev, win, client, evmask->mask_len * 4, (unsigned char*)&evmask[1]);
evmask = (xXIDeviceEventMask*)(((unsigned char*)evmask) + evmask->mask_len * 4);
evmask = (xXIEventMask*)(((unsigned char*)evmask) + evmask->mask_len * 4);
}
RecalculateDeliverableEvents(win);

30
Xi/xisetdevfocus.c
View File

@ -41,39 +41,39 @@
#include "xisetdevfocus.h"
int
SProcXISetDeviceFocus(ClientPtr client)
SProcXISetFocus(ClientPtr client)
{
char n;
REQUEST(xXISetDeviceFocusReq);
REQUEST(xXISetFocusReq);
swaps(&stuff->length, n);
swaps(&stuff->deviceid, n);
swapl(&stuff->focus, n);
swapl(&stuff->time, n);
return ProcXISetDeviceFocus(client);
return ProcXISetFocus(client);
}
int
SProcXIGetDeviceFocus(ClientPtr client)
SProcXIGetFocus(ClientPtr client)
{
char n;
REQUEST(xXIGetDeviceFocusReq);
REQUEST(xXIGetFocusReq);
swaps(&stuff->length, n);
swaps(&stuff->deviceid, n);
return ProcXIGetDeviceFocus(client);
return ProcXIGetFocus(client);
}
int
ProcXISetDeviceFocus(ClientPtr client)
ProcXISetFocus(ClientPtr client)
{
DeviceIntPtr dev;
int ret;
REQUEST(xXISetDeviceFocusReq);
REQUEST_AT_LEAST_SIZE(xXISetDeviceFocusReq);
REQUEST(xXISetFocusReq);
REQUEST_AT_LEAST_SIZE(xXISetFocusReq);
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixSetFocusAccess);
if (ret != Success)
@ -86,14 +86,14 @@ ProcXISetDeviceFocus(ClientPtr client)
}
int
ProcXIGetDeviceFocus(ClientPtr client)
ProcXIGetFocus(ClientPtr client)
{
xXIGetDeviceFocusReply rep;
xXIGetFocusReply rep;
DeviceIntPtr dev;
int ret;
REQUEST(xXIGetDeviceFocusReq);
REQUEST_AT_LEAST_SIZE(xXIGetDeviceFocusReq);
REQUEST(xXIGetFocusReq);
REQUEST_AT_LEAST_SIZE(xXIGetFocusReq);
ret = dixLookupDevice(&dev, stuff->deviceid, client, DixGetFocusAccess);
if (ret != Success)
@ -102,7 +102,7 @@ ProcXIGetDeviceFocus(ClientPtr client)
return BadDevice;
rep.repType = X_Reply;
rep.RepType = X_XIGetDeviceFocus;
rep.RepType = X_XIGetFocus;
rep.length = 0;
rep.sequenceNumber = client->sequence;
@ -115,6 +115,6 @@ ProcXIGetDeviceFocus(ClientPtr client)
else
rep.focus = dev->focus->win->drawable.id;
WriteReplyToClient(client, sizeof(xXIGetDeviceFocusReply), &rep);
WriteReplyToClient(client, sizeof(xXIGetFocusReply), &rep);
return Success;
}

8
Xi/xisetdevfocus.h
View File

@ -26,10 +26,10 @@
#ifndef XISETDEVFOCUS_H
#define XISETDEVFOCUS_H 1
int SProcXISetDeviceFocus(ClientPtr client);
int ProcXISetDeviceFocus(ClientPtr client);
int SProcXISetFocus(ClientPtr client);
int ProcXISetFocus(ClientPtr client);
int SProcXIGetDeviceFocus(ClientPtr client);
int ProcXIGetDeviceFocus(ClientPtr client);
int SProcXIGetFocus(ClientPtr client);
int ProcXIGetFocus(ClientPtr client);
#endif /* XISETDEVFOCUS_H */

6
dix/eventconvert.c
View File

@ -422,9 +422,9 @@ eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
static int
eventToRawEvent(RawDeviceEvent *ev, xEvent **xi)
{
xXIRawDeviceEvent* raw;
xXIRawEvent* raw;
int vallen, nvals;
int i, len = sizeof(xXIRawDeviceEvent);
int i, len = sizeof(xXIRawEvent);
char *ptr;
FP3232 *axisval;
@ -435,7 +435,7 @@ eventToRawEvent(RawDeviceEvent *ev, xEvent **xi)
len += vallen * 4; /* valuators mask */
*xi = xcalloc(1, len);
raw = (xXIRawDeviceEvent*)*xi;
raw = (xXIRawEvent*)*xi;
raw->type = GenericEvent;
raw->extension = IReqCode;
raw->evtype = GetXI2Type((InternalEvent*)ev);

10
test/input.c
View File

@ -284,16 +284,16 @@ static void xi2_struct_sizes(void)
g_assert(sizeof(req) == sz_##req);
compare(xXIQueryVersionReq);
compare(xXIWarpDevicePointerReq);
compare(xXIChangeDeviceCursorReq);
compare(xXIChangeDeviceHierarchyReq);
compare(xXIWarpPointerReq);
compare(xXIChangeCursorReq);
compare(xXIChangeHierarchyReq);
compare(xXISetClientPointerReq);
compare(xXIGetClientPointerReq);
compare(xXISelectEventsReq);
compare(xXIQueryVersionReq);
compare(xXIQueryDeviceReq);
compare(xXISetDeviceFocusReq);
compare(xXIGetDeviceFocusReq);
compare(xXISetFocusReq);
compare(xXIGetFocusReq);
compare(xXIGrabDeviceReq);
compare(xXIUngrabDeviceReq);
compare(xXIAllowEventsReq);