hashirama/xserver
Watch
0
0
Fork
You've already forked xserver
 0
mirror of https://github.com/X11Libre/xserver.git synced 2026-10-29 02:31:18 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into dcdc_rework

Browse source 
Conflicts:

	Xext/xevie.c
	dix/dispatch.c
This commit is contained in:
Peter Hutterer 2008-04-07 07:56:41 +09:30
commit fd06e8f8c1
182 changed files with 5741 additions and 4820 deletions
Download patch file Download diff file Expand all files Collapse all files

122
Xext/xevie.c
View file

@ -63,11 +63,13 @@ extern Bool noXkbExtension;
#endif
extern int xeviegrabState;
static int ProcDispatch (ClientPtr client), SProcDispatch (ClientPtr client);
static void ResetProc (ExtensionEntry *extEntry);
static DISPATCH_PROC(ProcXevieDispatch);
static DISPATCH_PROC(SProcXevieDispatch);
static unsigned char ReqCode = 0;
static int ErrorBase;
static void XevieResetProc (ExtensionEntry *extEntry);
static unsigned char XevieReqCode = 0;
static int XevieErrorBase;
int xevieFlag = 0;
int xevieClientIndex = 0;
@ -77,7 +79,7 @@ Mask xevieMask = 0;
int xevieEventSent = 0;
int xevieKBEventSent = 0;
static DevPrivateKey xevieDevicePrivateKey = &xevieDevicePrivateKey;
static Bool xevieModifiersOn = FALSE;
static Bool xevieModifiersOn = FALSE;
#define XEVIEINFO(dev) ((xevieDeviceInfoPtr) \
dixLookupPrivate(&(dev)->devPrivates, xevieDevicePrivateKey))
@ -108,11 +110,6 @@ typedef struct {
static xevieKeycQueueRec keycq[KEYC_QUEUE_SIZE] = {{0, NULL}};
static int keycqHead = 0, keycqTail = 0;
static int ProcDispatch (ClientPtr), SProcDispatch (ClientPtr);
static void ResetProc (ExtensionEntry*);
static int ErrorBase;
static Bool XevieStart(void);
static void XevieEnd(int clientIndex);
static void XevieClientStateCallback(CallbackListPtr *pcbl, pointer nulldata,
@ -140,25 +137,23 @@ XevieExtensionInit (void)
if ((extEntry = AddExtension (XEVIENAME,
0,
XevieNumberErrors,
ProcDispatch,
SProcDispatch,
ResetProc,
ProcXevieDispatch,
SProcXevieDispatch,
XevieResetProc,
StandardMinorOpcode))) {
ReqCode = (unsigned char)extEntry->base;
ErrorBase = extEntry->errorBase;
XevieReqCode = (unsigned char)extEntry->base;
XevieErrorBase = extEntry->errorBase;
}
/* PC servers initialize the desktop colors (citems) here! */
}
/*ARGSUSED*/
static
void ResetProc (ExtensionEntry *extEntry)
void XevieResetProc (ExtensionEntry *extEntry)
{
}
static
int ProcQueryVersion (ClientPtr client)
int ProcXevieQueryVersion (ClientPtr client)
{
xXevieQueryVersionReply rep;
@ -173,7 +168,7 @@ int ProcQueryVersion (ClientPtr client)
}
static
int ProcStart (ClientPtr client)
int ProcXevieStart (ClientPtr client)
{
xXevieStartReply rep;
@ -214,10 +209,12 @@ int ProcStart (ClientPtr client)
}
static
int ProcEnd (ClientPtr client)
int ProcXevieEnd (ClientPtr client)
{
xXevieEndReply rep;
REQUEST_SIZE_MATCH (xXevieEndReq);
if (xevieFlag) {
if (client->index != xevieClientIndex)
return BadAccess;
@ -233,13 +230,15 @@ int ProcEnd (ClientPtr client)
}
static
int ProcSend (ClientPtr client)
int ProcXevieSend (ClientPtr client)
{
REQUEST (xXevieSendReq);
xXevieSendReply rep;
xEvent *xE;
static unsigned char lastDetail = 0, lastType = 0;
REQUEST_SIZE_MATCH (xXevieSendReq);
if (client->index != xevieClientIndex)
return BadAccess;
@ -279,15 +278,17 @@ int ProcSend (ClientPtr client)
}
static
int ProcSelectInput (ClientPtr client)
int ProcXevieSelectInput (ClientPtr client)
{
REQUEST (xXevieSelectInputReq);
xXevieSelectInputReply rep;
REQUEST_SIZE_MATCH (xXevieSelectInputReq);
if (client->index != xevieClientIndex)
return BadAccess;
xevieMask = (long)stuff->event_mask;
xevieMask = stuff->event_mask;
rep.type = X_Reply;
rep.sequence_number = client->sequence;
WriteToClient (client, sizeof (xXevieSelectInputReply), (char *)&rep);
@ -295,101 +296,114 @@ int ProcSelectInput (ClientPtr client)
}
static
int ProcDispatch (ClientPtr client)
int ProcXevieDispatch (ClientPtr client)
{
REQUEST (xReq);
switch (stuff->data)
{
case X_XevieQueryVersion:
return ProcQueryVersion (client);
return ProcXevieQueryVersion (client);
case X_XevieStart:
return ProcStart (client);
return ProcXevieStart (client);
case X_XevieEnd:
return ProcEnd (client);
return ProcXevieEnd (client);
case X_XevieSend:
return ProcSend (client);
return ProcXevieSend (client);
case X_XevieSelectInput:
return ProcSelectInput(client);
return ProcXevieSelectInput(client);
default:
return BadRequest;
}
}
static
int SProcQueryVersion (ClientPtr client)
int SProcXevieQueryVersion (ClientPtr client)
{
int n;
REQUEST(xXevieQueryVersionReq);
swaps(&stuff->length, n);
return ProcQueryVersion(client);
swaps (&stuff->length, n);
REQUEST_SIZE_MATCH (xXevieQueryVersionReq);
swaps (&stuff->client_major_version, n);
swaps (&stuff->client_minor_version, n);
return ProcXevieQueryVersion(client);
}
static
int SProcStart (ClientPtr client)
int SProcXevieStart (ClientPtr client)
{
int n;
REQUEST (xXevieStartReq);
swaps (&stuff->length, n);
REQUEST_SIZE_MATCH (xXevieStartReq);
swapl (&stuff->screen, n);
REQUEST_AT_LEAST_SIZE (xXevieStartReq);
return ProcStart (client);
return ProcXevieStart (client);
}
static
int SProcEnd (ClientPtr client)
int SProcXevieEnd (ClientPtr client)
{
int n;
REQUEST (xXevieEndReq);
swaps (&stuff->length, n);
REQUEST_AT_LEAST_SIZE (xXevieEndReq);
swapl(&stuff->cmap, n);
return ProcEnd (client);
REQUEST_SIZE_MATCH (xXevieEndReq);
swapl (&stuff->cmap, n);
return ProcXevieEnd (client);
}
static
int SProcSend (ClientPtr client)
int SProcXevieSend (ClientPtr client)
{
int n;
xEvent eventT;
EventSwapPtr proc;
REQUEST (xXevieSendReq);
swaps (&stuff->length, n);
REQUEST_AT_LEAST_SIZE (xXevieSendReq);
swapl(&stuff->event, n);
return ProcSend (client);
REQUEST_SIZE_MATCH (xXevieSendReq);
swapl (&stuff->dataType, n);
/* Swap event */
proc = EventSwapVector[stuff->event.u.u.type & 0177];
if (!proc || proc == NotImplemented) /* no swapping proc; invalid event type? */
return (BadValue);
(*proc)(&stuff->event, &eventT);
stuff->event = eventT;
return ProcXevieSend (client);
}
static
int SProcSelectInput (ClientPtr client)
int SProcXevieSelectInput (ClientPtr client)
{
int n;
REQUEST (xXevieSelectInputReq);
swaps (&stuff->length, n);
REQUEST_AT_LEAST_SIZE (xXevieSelectInputReq);
swapl(&stuff->event_mask, n);
return ProcSelectInput (client);
REQUEST_SIZE_MATCH (xXevieSelectInputReq);
swapl (&stuff->event_mask, n);
return ProcXevieSelectInput (client);
}
static
int SProcDispatch (ClientPtr client)
int SProcXevieDispatch (ClientPtr client)
{
REQUEST(xReq);
switch (stuff->data)
{
case X_XevieQueryVersion:
return SProcQueryVersion (client);
return SProcXevieQueryVersion (client);
case X_XevieStart:
return SProcStart (client);
return SProcXevieStart (client);
case X_XevieEnd:
return SProcEnd (client);
return SProcXevieEnd (client);
case X_XevieSend:
return SProcSend (client);
return SProcXevieSend (client);
case X_XevieSelectInput:
return SProcSelectInput(client);
return SProcXevieSelectInput(client);
default:
return BadRequest;
}