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

Introduce a consistent coding style

Browse source 
This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
This commit is contained in:
Keith Packard 2012-03-21 12:55:09 -07:00
commit 9838b7032e
1258 changed files with 264655 additions and 259938 deletions
Download patch file Download diff file Expand all files Collapse all files

1137
xfixes/cursor.c
View file

File diff suppressed because it is too large Load diff

758
xfixes/region.c
View file

File diff suppressed because it is too large Load diff

32
xfixes/saveset.c
View file

@ -29,31 +29,29 @@
int
ProcXFixesChangeSaveSet(ClientPtr client)
{
Bool toRoot, map;
int result;
WindowPtr pWin;
Bool toRoot, map;
int result;
WindowPtr pWin;
REQUEST(xXFixesChangeSaveSetReq);
REQUEST_SIZE_MATCH(xXFixesChangeSaveSetReq);
result = dixLookupWindow(&pWin, stuff->window, client, DixManageAccess);
if (result != Success)
return result;
if (client->clientAsMask == (CLIENT_BITS(pWin->drawable.id)))
return BadMatch;
if ((stuff->mode != SetModeInsert) && (stuff->mode != SetModeDelete))
{
client->errorValue = stuff->mode;
return BadValue;
if ((stuff->mode != SetModeInsert) && (stuff->mode != SetModeDelete)) {
client->errorValue = stuff->mode;
return BadValue;
}
if ((stuff->target != SaveSetNearest) && (stuff->target != SaveSetRoot))
{
client->errorValue = stuff->target;
return BadValue;
if ((stuff->target != SaveSetNearest) && (stuff->target != SaveSetRoot)) {
client->errorValue = stuff->target;
return BadValue;
}
if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap))
{
client->errorValue = stuff->map;
return BadValue;
if ((stuff->map != SaveSetMap) && (stuff->map != SaveSetUnmap)) {
client->errorValue = stuff->map;
return BadValue;
}
toRoot = (stuff->target == SaveSetRoot);
map = (stuff->map == SaveSetMap);
@ -67,5 +65,5 @@ SProcXFixesChangeSaveSet(ClientPtr client)
swaps(&stuff->length);
swapl(&stuff->window);
return (*ProcXFixesVector[stuff->xfixesReqType])(client);
return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
}

302
xfixes/select.c
View file

@ -27,8 +27,8 @@
#include "xfixesint.h"
#include "xace.h"
static RESTYPE SelectionClientType, SelectionWindowType;
static Bool SelectionCallbackRegistered = FALSE;
static RESTYPE SelectionClientType, SelectionWindowType;
static Bool SelectionCallbackRegistered = FALSE;
/*
* There is a global list of windows selecting for selection events
@ -40,83 +40,76 @@ static Bool SelectionCallbackRegistered = FALSE;
typedef struct _SelectionEvent *SelectionEventPtr;
typedef struct _SelectionEvent {
SelectionEventPtr next;
Atom selection;
CARD32 eventMask;
ClientPtr pClient;
WindowPtr pWindow;
XID clientResource;
SelectionEventPtr next;
Atom selection;
CARD32 eventMask;
ClientPtr pClient;
WindowPtr pWindow;
XID clientResource;
} SelectionEventRec;
static SelectionEventPtr selectionEvents;
static SelectionEventPtr selectionEvents;
static void
XFixesSelectionCallback (CallbackListPtr *callbacks, pointer data, pointer args)
XFixesSelectionCallback(CallbackListPtr *callbacks, pointer data, pointer args)
{
SelectionEventPtr e;
SelectionInfoRec *info = (SelectionInfoRec *) args;
Selection *selection = info->selection;
int subtype;
CARD32 eventMask;
SelectionEventPtr e;
SelectionInfoRec *info = (SelectionInfoRec *) args;
Selection *selection = info->selection;
int subtype;
CARD32 eventMask;
switch (info->kind) {
case SelectionSetOwner:
subtype = XFixesSetSelectionOwnerNotify;
eventMask = XFixesSetSelectionOwnerNotifyMask;
break;
subtype = XFixesSetSelectionOwnerNotify;
eventMask = XFixesSetSelectionOwnerNotifyMask;
break;
case SelectionWindowDestroy:
subtype = XFixesSelectionWindowDestroyNotify;
eventMask = XFixesSelectionWindowDestroyNotifyMask;
break;
subtype = XFixesSelectionWindowDestroyNotify;
eventMask = XFixesSelectionWindowDestroyNotifyMask;
break;
case SelectionClientClose:
subtype = XFixesSelectionClientCloseNotify;
eventMask = XFixesSelectionClientCloseNotifyMask;
break;
subtype = XFixesSelectionClientCloseNotify;
eventMask = XFixesSelectionClientCloseNotifyMask;
break;
default:
return;
return;
}
for (e = selectionEvents; e; e = e->next)
{
if (e->selection == selection->selection &&
(e->eventMask & eventMask))
{
xXFixesSelectionNotifyEvent ev;
for (e = selectionEvents; e; e = e->next) {
if (e->selection == selection->selection && (e->eventMask & eventMask)) {
xXFixesSelectionNotifyEvent ev;
memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
ev.type = XFixesEventBase + XFixesSelectionNotify;
ev.subtype = subtype;
ev.window = e->pWindow->drawable.id;
if (subtype == XFixesSetSelectionOwnerNotify)
ev.owner = selection->window;
else
ev.owner = 0;
ev.selection = e->selection;
ev.timestamp = currentTime.milliseconds;
ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;
WriteEventsToClient (e->pClient, 1, (xEvent *) &ev);
}
memset(&ev, 0, sizeof(xXFixesSelectionNotifyEvent));
ev.type = XFixesEventBase + XFixesSelectionNotify;
ev.subtype = subtype;
ev.window = e->pWindow->drawable.id;
if (subtype == XFixesSetSelectionOwnerNotify)
ev.owner = selection->window;
else
ev.owner = 0;
ev.selection = e->selection;
ev.timestamp = currentTime.milliseconds;
ev.selectionTimestamp = selection->lastTimeChanged.milliseconds;
WriteEventsToClient(e->pClient, 1, (xEvent *) &ev);
}
}
}
static Bool
CheckSelectionCallback (void)
CheckSelectionCallback(void)
{
if (selectionEvents)
{
if (!SelectionCallbackRegistered)
{
if (!AddCallback (&SelectionCallback, XFixesSelectionCallback, NULL))
return FALSE;
SelectionCallbackRegistered = TRUE;
}
if (selectionEvents) {
if (!SelectionCallbackRegistered) {
if (!AddCallback(&SelectionCallback, XFixesSelectionCallback, NULL))
return FALSE;
SelectionCallbackRegistered = TRUE;
}
}
else
{
if (SelectionCallbackRegistered)
{
DeleteCallback (&SelectionCallback, XFixesSelectionCallback, NULL);
SelectionCallbackRegistered = FALSE;
}
else {
if (SelectionCallbackRegistered) {
DeleteCallback(&SelectionCallback, XFixesSelectionCallback, NULL);
SelectionCallbackRegistered = FALSE;
}
}
return TRUE;
}
@ -126,99 +119,88 @@ CheckSelectionCallback (void)
XFixesSelectionClientCloseNotifyMask)
static int
XFixesSelectSelectionInput (ClientPtr pClient,
Atom selection,
WindowPtr pWindow,
CARD32 eventMask)
XFixesSelectSelectionInput(ClientPtr pClient,
Atom selection, WindowPtr pWindow, CARD32 eventMask)
{
pointer val;
int rc;
SelectionEventPtr *prev, e;
SelectionEventPtr *prev, e;
rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess);
if (rc != Success)
return rc;
return rc;
for (prev = &selectionEvents; (e = *prev); prev = &e->next)
{
if (e->selection == selection &&
e->pClient == pClient &&
e->pWindow == pWindow)
{
break;
}
for (prev = &selectionEvents; (e = *prev); prev = &e->next) {
if (e->selection == selection &&
e->pClient == pClient && e->pWindow == pWindow) {
break;
}
}
if (!eventMask)
{
if (e)
{
FreeResource (e->clientResource, 0);
}
return Success;
if (!eventMask) {
if (e) {
FreeResource(e->clientResource, 0);
}
return Success;
}
if (!e)
{
e = (SelectionEventPtr) malloc(sizeof (SelectionEventRec));
if (!e)
return BadAlloc;
if (!e) {
e = (SelectionEventPtr) malloc(sizeof(SelectionEventRec));
if (!e)
return BadAlloc;
e->next = 0;
e->selection = selection;
e->pClient = pClient;
e->pWindow = pWindow;
e->clientResource = FakeClientID(pClient->index);
e->next = 0;
e->selection = selection;
e->pClient = pClient;
e->pWindow = pWindow;
e->clientResource = FakeClientID(pClient->index);
/*
* Add a resource hanging from the window to
* catch window destroy
*/
rc = dixLookupResourceByType (&val, pWindow->drawable.id,
SelectionWindowType, serverClient,
DixGetAttrAccess);
if (rc != Success)
if (!AddResource (pWindow->drawable.id, SelectionWindowType,
(pointer) pWindow))
{
free(e);
return BadAlloc;
}
/*
* Add a resource hanging from the window to
* catch window destroy
*/
rc = dixLookupResourceByType(&val, pWindow->drawable.id,
SelectionWindowType, serverClient,
DixGetAttrAccess);
if (rc != Success)
if (!AddResource(pWindow->drawable.id, SelectionWindowType,
(pointer) pWindow)) {
free(e);
return BadAlloc;
}
if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
return BadAlloc;
if (!AddResource(e->clientResource, SelectionClientType, (pointer) e))
return BadAlloc;
*prev = e;
if (!CheckSelectionCallback ())
{
FreeResource (e->clientResource, 0);
return BadAlloc;
}
*prev = e;
if (!CheckSelectionCallback()) {
FreeResource(e->clientResource, 0);
return BadAlloc;
}
}
e->eventMask = eventMask;
return Success;
}
int
ProcXFixesSelectSelectionInput (ClientPtr client)
ProcXFixesSelectSelectionInput(ClientPtr client)
{
REQUEST (xXFixesSelectSelectionInputReq);
WindowPtr pWin;
int rc;
REQUEST(xXFixesSelectSelectionInputReq);
WindowPtr pWin;
int rc;
REQUEST_SIZE_MATCH (xXFixesSelectSelectionInputReq);
REQUEST_SIZE_MATCH(xXFixesSelectSelectionInputReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess);
if (rc != Success)
return rc;
if (stuff->eventMask & ~SelectionAllEvents)
{
client->errorValue = stuff->eventMask;
return BadValue;
if (stuff->eventMask & ~SelectionAllEvents) {
client->errorValue = stuff->eventMask;
return BadValue;
}
return XFixesSelectSelectionInput (client, stuff->selection,
pWin, stuff->eventMask);
return XFixesSelectSelectionInput(client, stuff->selection,
pWin, stuff->eventMask);
}
int
SProcXFixesSelectSelectionInput (ClientPtr client)
SProcXFixesSelectSelectionInput(ClientPtr client)
{
REQUEST(xXFixesSelectSelectionInputReq);
@ -226,64 +208,60 @@ SProcXFixesSelectSelectionInput (ClientPtr client)
swapl(&stuff->window);
swapl(&stuff->selection);
swapl(&stuff->eventMask);
return (*ProcXFixesVector[stuff->xfixesReqType])(client);
return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
}
void
SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
xXFixesSelectionNotifyEvent *to)
SXFixesSelectionNotifyEvent(xXFixesSelectionNotifyEvent * from,
xXFixesSelectionNotifyEvent * to)
{
to->type = from->type;
cpswaps (from->sequenceNumber, to->sequenceNumber);
cpswapl (from->window, to->window);
cpswapl (from->owner, to->owner);
cpswapl (from->selection, to->selection);
cpswapl (from->timestamp, to->timestamp);
cpswapl (from->selectionTimestamp, to->selectionTimestamp);
cpswaps(from->sequenceNumber, to->sequenceNumber);
cpswapl(from->window, to->window);
cpswapl(from->owner, to->owner);
cpswapl(from->selection, to->selection);
cpswapl(from->timestamp, to->timestamp);
cpswapl(from->selectionTimestamp, to->selectionTimestamp);
}
static int
SelectionFreeClient (pointer data, XID id)
SelectionFreeClient(pointer data, XID id)
{
SelectionEventPtr old = (SelectionEventPtr) data;
SelectionEventPtr *prev, e;
for (prev = &selectionEvents; (e = *prev); prev = &e->next)
{
if (e == old)
{
*prev = e->next;
free(e);
CheckSelectionCallback ();
break;
}
SelectionEventPtr old = (SelectionEventPtr) data;
SelectionEventPtr *prev, e;
for (prev = &selectionEvents; (e = *prev); prev = &e->next) {
if (e == old) {
*prev = e->next;
free(e);
CheckSelectionCallback();
break;
}
}
return 1;
}
static int
SelectionFreeWindow (pointer data, XID id)
SelectionFreeWindow(pointer data, XID id)
{
WindowPtr pWindow = (WindowPtr) data;
SelectionEventPtr e, next;
WindowPtr pWindow = (WindowPtr) data;
SelectionEventPtr e, next;
for (e = selectionEvents; e; e = next)
{
next = e->next;
if (e->pWindow == pWindow)
{
FreeResource (e->clientResource, 0);
}
for (e = selectionEvents; e; e = next) {
next = e->next;
if (e->pWindow == pWindow) {
FreeResource(e->clientResource, 0);
}
}
return 1;
}
Bool
XFixesSelectionInit (void)
XFixesSelectionInit(void)
{
SelectionClientType = CreateNewResourceType(SelectionFreeClient,
"XFixesSelectionClient");
"XFixesSelectionClient");
SelectionWindowType = CreateNewResourceType(SelectionFreeWindow,
"XFixesSelectionWindow");
"XFixesSelectionWindow");
return SelectionClientType && SelectionWindowType;
}

258
xfixes/xfixes.c
View file

@ -49,18 +49,20 @@
#include "xfixesint.h"
#include "protocol-versions.h"
static unsigned char XFixesReqCode;
int XFixesEventBase;
int XFixesErrorBase;
static unsigned char XFixesReqCode;
int XFixesEventBase;
int XFixesErrorBase;
static DevPrivateKeyRec XFixesClientPrivateKeyRec;
#define XFixesClientPrivateKey (&XFixesClientPrivateKeyRec)
static int
ProcXFixesQueryVersion(ClientPtr client)
{
XFixesClientPtr pXFixesClient = GetXFixesClient (client);
XFixesClientPtr pXFixesClient = GetXFixesClient(client);
xXFixesQueryVersionReply rep;
REQUEST(xXFixesQueryVersionReq);
REQUEST_SIZE_MATCH(xXFixesQueryVersionReq);
@ -70,90 +72,86 @@ ProcXFixesQueryVersion(ClientPtr client)
rep.sequenceNumber = client->sequence;
if (version_compare(stuff->majorVersion, stuff->minorVersion,
SERVER_XFIXES_MAJOR_VERSION, SERVER_XFIXES_MAJOR_VERSION) < 0)
{
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
} else {
rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
SERVER_XFIXES_MAJOR_VERSION,
SERVER_XFIXES_MAJOR_VERSION) < 0) {
rep.majorVersion = stuff->majorVersion;
rep.minorVersion = stuff->minorVersion;
}
else {
rep.majorVersion = SERVER_XFIXES_MAJOR_VERSION;
rep.minorVersion = SERVER_XFIXES_MINOR_VERSION;
}
pXFixesClient->major_version = rep.majorVersion;
pXFixesClient->minor_version = rep.minorVersion;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.majorVersion);
swapl(&rep.minorVersion);
}
WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *)&rep);
WriteToClient(client, sizeof(xXFixesQueryVersionReply), (char *) &rep);
return Success;
}
/* Major version controls available requests */
static const int version_requests[] = {
X_XFixesQueryVersion, /* before client sends QueryVersion */
X_XFixesGetCursorImage, /* Version 1 */
X_XFixesChangeCursorByName, /* Version 2 */
X_XFixesExpandRegion, /* Version 3 */
X_XFixesShowCursor, /* Version 4 */
X_XFixesDestroyPointerBarrier, /* Version 5 */
X_XFixesQueryVersion, /* before client sends QueryVersion */
X_XFixesGetCursorImage, /* Version 1 */
X_XFixesChangeCursorByName, /* Version 2 */
X_XFixesExpandRegion, /* Version 3 */
X_XFixesShowCursor, /* Version 4 */
X_XFixesDestroyPointerBarrier, /* Version 5 */
};
#define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0]))
int (*ProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {
int (*ProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = {
/*************** Version 1 ******************/
ProcXFixesQueryVersion,
ProcXFixesChangeSaveSet,
ProcXFixesSelectSelectionInput,
ProcXFixesSelectCursorInput,
ProcXFixesGetCursorImage,
ProcXFixesChangeSaveSet,
ProcXFixesSelectSelectionInput,
ProcXFixesSelectCursorInput, ProcXFixesGetCursorImage,
/*************** Version 2 ******************/
ProcXFixesCreateRegion,
ProcXFixesCreateRegionFromBitmap,
ProcXFixesCreateRegionFromWindow,
ProcXFixesCreateRegionFromGC,
ProcXFixesCreateRegionFromPicture,
ProcXFixesDestroyRegion,
ProcXFixesSetRegion,
ProcXFixesCopyRegion,
ProcXFixesCombineRegion,
ProcXFixesCombineRegion,
ProcXFixesCombineRegion,
ProcXFixesInvertRegion,
ProcXFixesTranslateRegion,
ProcXFixesRegionExtents,
ProcXFixesFetchRegion,
ProcXFixesSetGCClipRegion,
ProcXFixesSetWindowShapeRegion,
ProcXFixesSetPictureClipRegion,
ProcXFixesSetCursorName,
ProcXFixesGetCursorName,
ProcXFixesGetCursorImageAndName,
ProcXFixesChangeCursor,
ProcXFixesChangeCursorByName,
ProcXFixesCreateRegion,
ProcXFixesCreateRegionFromBitmap,
ProcXFixesCreateRegionFromWindow,
ProcXFixesCreateRegionFromGC,
ProcXFixesCreateRegionFromPicture,
ProcXFixesDestroyRegion,
ProcXFixesSetRegion,
ProcXFixesCopyRegion,
ProcXFixesCombineRegion,
ProcXFixesCombineRegion,
ProcXFixesCombineRegion,
ProcXFixesInvertRegion,
ProcXFixesTranslateRegion,
ProcXFixesRegionExtents,
ProcXFixesFetchRegion,
ProcXFixesSetGCClipRegion,
ProcXFixesSetWindowShapeRegion,
ProcXFixesSetPictureClipRegion,
ProcXFixesSetCursorName,
ProcXFixesGetCursorName,
ProcXFixesGetCursorImageAndName,
ProcXFixesChangeCursor, ProcXFixesChangeCursorByName,
/*************** Version 3 ******************/
ProcXFixesExpandRegion,
ProcXFixesExpandRegion,
/*************** Version 4 ****************/
ProcXFixesHideCursor,
ProcXFixesShowCursor,
ProcXFixesHideCursor, ProcXFixesShowCursor,
/*************** Version 5 ****************/
ProcXFixesCreatePointerBarrier,
ProcXFixesDestroyPointerBarrier,
};
ProcXFixesCreatePointerBarrier, ProcXFixesDestroyPointerBarrier,};
static int
ProcXFixesDispatch (ClientPtr client)
ProcXFixesDispatch(ClientPtr client)
{
REQUEST(xXFixesReq);
XFixesClientPtr pXFixesClient = GetXFixesClient (client);
XFixesClientPtr pXFixesClient = GetXFixesClient(client);
if (pXFixesClient->major_version >= NUM_VERSION_REQUESTS)
return BadRequest;
return BadRequest;
if (stuff->xfixesReqType > version_requests[pXFixesClient->major_version])
return BadRequest;
return BadRequest;
return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
}
@ -168,74 +166,66 @@ SProcXFixesQueryVersion(ClientPtr client)
return (*ProcXFixesVector[stuff->xfixesReqType]) (client);
}
static int (*SProcXFixesVector[XFixesNumberRequests])(ClientPtr) = {
static int (*SProcXFixesVector[XFixesNumberRequests]) (ClientPtr) = {
/*************** Version 1 ******************/
SProcXFixesQueryVersion,
SProcXFixesChangeSaveSet,
SProcXFixesSelectSelectionInput,
SProcXFixesSelectCursorInput,
SProcXFixesGetCursorImage,
SProcXFixesChangeSaveSet,
SProcXFixesSelectSelectionInput,
SProcXFixesSelectCursorInput, SProcXFixesGetCursorImage,
/*************** Version 2 ******************/
SProcXFixesCreateRegion,
SProcXFixesCreateRegionFromBitmap,
SProcXFixesCreateRegionFromWindow,
SProcXFixesCreateRegionFromGC,
SProcXFixesCreateRegionFromPicture,
SProcXFixesDestroyRegion,
SProcXFixesSetRegion,
SProcXFixesCopyRegion,
SProcXFixesCombineRegion,
SProcXFixesCombineRegion,
SProcXFixesCombineRegion,
SProcXFixesInvertRegion,
SProcXFixesTranslateRegion,
SProcXFixesRegionExtents,
SProcXFixesFetchRegion,
SProcXFixesSetGCClipRegion,
SProcXFixesSetWindowShapeRegion,
SProcXFixesSetPictureClipRegion,
SProcXFixesSetCursorName,
SProcXFixesGetCursorName,
SProcXFixesGetCursorImageAndName,
SProcXFixesChangeCursor,
SProcXFixesChangeCursorByName,
SProcXFixesCreateRegion,
SProcXFixesCreateRegionFromBitmap,
SProcXFixesCreateRegionFromWindow,
SProcXFixesCreateRegionFromGC,
SProcXFixesCreateRegionFromPicture,
SProcXFixesDestroyRegion,
SProcXFixesSetRegion,
SProcXFixesCopyRegion,
SProcXFixesCombineRegion,
SProcXFixesCombineRegion,
SProcXFixesCombineRegion,
SProcXFixesInvertRegion,
SProcXFixesTranslateRegion,
SProcXFixesRegionExtents,
SProcXFixesFetchRegion,
SProcXFixesSetGCClipRegion,
SProcXFixesSetWindowShapeRegion,
SProcXFixesSetPictureClipRegion,
SProcXFixesSetCursorName,
SProcXFixesGetCursorName,
SProcXFixesGetCursorImageAndName,
SProcXFixesChangeCursor, SProcXFixesChangeCursorByName,
/*************** Version 3 ******************/
SProcXFixesExpandRegion,
SProcXFixesExpandRegion,
/*************** Version 4 ****************/
SProcXFixesHideCursor,
SProcXFixesShowCursor,
SProcXFixesHideCursor, SProcXFixesShowCursor,
/*************** Version 5 ****************/
SProcXFixesCreatePointerBarrier,
SProcXFixesDestroyPointerBarrier,
};
SProcXFixesCreatePointerBarrier, SProcXFixesDestroyPointerBarrier,};
static int
SProcXFixesDispatch (ClientPtr client)
SProcXFixesDispatch(ClientPtr client)
{
REQUEST(xXFixesReq);
if (stuff->xfixesReqType >= XFixesNumberRequests)
return BadRequest;
return BadRequest;
return (*SProcXFixesVector[stuff->xfixesReqType]) (client);
}
static void
XFixesClientCallback (CallbackListPtr *list,
pointer closure,
pointer data)
XFixesClientCallback(CallbackListPtr *list, pointer closure, pointer data)
{
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
ClientPtr pClient = clientinfo->client;
XFixesClientPtr pXFixesClient = GetXFixesClient (pClient);
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
ClientPtr pClient = clientinfo->client;
XFixesClientPtr pXFixesClient = GetXFixesClient(pClient);
pXFixesClient->major_version = 0;
pXFixesClient->minor_version = 0;
}
/*ARGSUSED*/
static void
XFixesResetProc (ExtensionEntry *extEntry)
/*ARGSUSED*/ static void
XFixesResetProc(ExtensionEntry * extEntry)
{
DeleteCallback (&ClientStateCallback, XFixesClientCallback, 0);
DeleteCallback(&ClientStateCallback, XFixesClientCallback, 0);
}
void
@ -243,56 +233,58 @@ XFixesExtensionInit(void)
{
ExtensionEntry *extEntry;
if (!dixRegisterPrivateKey(&XFixesClientPrivateKeyRec, PRIVATE_CLIENT, sizeof (XFixesClientRec)))
return;
if (!AddCallback (&ClientStateCallback, XFixesClientCallback, 0))
return;
if (!dixRegisterPrivateKey
(&XFixesClientPrivateKeyRec, PRIVATE_CLIENT, sizeof(XFixesClientRec)))
return;
if (!AddCallback(&ClientStateCallback, XFixesClientCallback, 0))
return;
if (XFixesSelectionInit() && XFixesCursorInit () && XFixesRegionInit () &&
(extEntry = AddExtension(XFIXES_NAME, XFixesNumberEvents,
XFixesNumberErrors,
ProcXFixesDispatch, SProcXFixesDispatch,
XFixesResetProc, StandardMinorOpcode)) != 0)
{
XFixesReqCode = (unsigned char)extEntry->base;
XFixesEventBase = extEntry->eventBase;
XFixesErrorBase = extEntry->errorBase;
EventSwapVector[XFixesEventBase + XFixesSelectionNotify] =
(EventSwapPtr) SXFixesSelectionNotifyEvent;
EventSwapVector[XFixesEventBase + XFixesCursorNotify] =
(EventSwapPtr) SXFixesCursorNotifyEvent;
SetResourceTypeErrorValue(RegionResType, XFixesErrorBase + BadRegion);
SetResourceTypeErrorValue(PointerBarrierType,
XFixesErrorBase + BadBarrier);
if (XFixesSelectionInit() && XFixesCursorInit() && XFixesRegionInit() &&
(extEntry = AddExtension(XFIXES_NAME, XFixesNumberEvents,
XFixesNumberErrors,
ProcXFixesDispatch, SProcXFixesDispatch,
XFixesResetProc, StandardMinorOpcode)) != 0) {
XFixesReqCode = (unsigned char) extEntry->base;
XFixesEventBase = extEntry->eventBase;
XFixesErrorBase = extEntry->errorBase;
EventSwapVector[XFixesEventBase + XFixesSelectionNotify] =
(EventSwapPtr) SXFixesSelectionNotifyEvent;
EventSwapVector[XFixesEventBase + XFixesCursorNotify] =
(EventSwapPtr) SXFixesCursorNotifyEvent;
SetResourceTypeErrorValue(RegionResType, XFixesErrorBase + BadRegion);
SetResourceTypeErrorValue(PointerBarrierType,
XFixesErrorBase + BadBarrier);
}
}
#ifdef PANORAMIX
int (*PanoramiXSaveXFixesVector[XFixesNumberRequests])(ClientPtr);
int (*PanoramiXSaveXFixesVector[XFixesNumberRequests]) (ClientPtr);
void
PanoramiXFixesInit (void)
PanoramiXFixesInit(void)
{
int i;
for (i = 0; i < XFixesNumberRequests; i++)
PanoramiXSaveXFixesVector[i] = ProcXFixesVector[i];
PanoramiXSaveXFixesVector[i] = ProcXFixesVector[i];
/*
* Stuff in Xinerama aware request processing hooks
*/
ProcXFixesVector[X_XFixesSetGCClipRegion] = PanoramiXFixesSetGCClipRegion;
ProcXFixesVector[X_XFixesSetWindowShapeRegion] = PanoramiXFixesSetWindowShapeRegion;
ProcXFixesVector[X_XFixesSetPictureClipRegion] = PanoramiXFixesSetPictureClipRegion;
ProcXFixesVector[X_XFixesSetWindowShapeRegion] =
PanoramiXFixesSetWindowShapeRegion;
ProcXFixesVector[X_XFixesSetPictureClipRegion] =
PanoramiXFixesSetPictureClipRegion;
}
void
PanoramiXFixesReset (void)
PanoramiXFixesReset(void)
{
int i;
for (i = 0; i < XFixesNumberRequests; i++)
ProcXFixesVector[i] = PanoramiXSaveXFixesVector[i];
ProcXFixesVector[i] = PanoramiXSaveXFixesVector[i];
}
#endif

17
xfixes/xfixes.h
View file

@ -50,23 +50,22 @@ extern _X_EXPORT int XFixesErrorBase;
}
extern _X_EXPORT RegionPtr
XFixesRegionCopy (RegionPtr pRegion);
XFixesRegionCopy(RegionPtr pRegion);
struct PointerBarrier {
CARD16 x1, x2, y1, y2;
CARD32 directions;
};
extern int
barrier_get_direction(int, int, int, int);
barrier_get_direction(int, int, int, int);
extern BOOL
barrier_is_blocking(const struct PointerBarrier*, int, int, int, int, double*);
extern BOOL
barrier_is_blocking_direction(const struct PointerBarrier*, int);
barrier_is_blocking(const struct PointerBarrier *, int, int, int, int,
double *);
extern BOOL barrier_is_blocking_direction(const struct PointerBarrier *, int);
extern void
barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x, int *y);
barrier_clamp_to_barrier(struct PointerBarrier *barrier, int dir, int *x,
int *y);
#endif /* _XFIXES_H_ */
#endif /* _XFIXES_H_ */

176
xfixes/xfixesint.h
View file

@ -60,242 +60,244 @@
#include "selection.h"
#include "xfixes.h"
extern int XFixesEventBase;
extern int XFixesEventBase;
typedef struct _XFixesClient {
CARD32 major_version;
CARD32 minor_version;
CARD32 major_version;
CARD32 minor_version;
} XFixesClientRec, *XFixesClientPtr;
#define GetXFixesClient(pClient) ((XFixesClientPtr)dixLookupPrivate(&(pClient)->devPrivates, XFixesClientPrivateKey))
extern int (*ProcXFixesVector[XFixesNumberRequests])(ClientPtr);
extern int (*ProcXFixesVector[XFixesNumberRequests]) (ClientPtr);
/* Initialize extension at server startup time */
void
XFixesExtensionInit(void);
XFixesExtensionInit(void);
/* Save set */
int
ProcXFixesChangeSaveSet(ClientPtr client);
ProcXFixesChangeSaveSet(ClientPtr client);
int
SProcXFixesChangeSaveSet(ClientPtr client);
SProcXFixesChangeSaveSet(ClientPtr client);
/* Selection events */
int
ProcXFixesSelectSelectionInput (ClientPtr client);
ProcXFixesSelectSelectionInput(ClientPtr client);
int
SProcXFixesSelectSelectionInput (ClientPtr client);
SProcXFixesSelectSelectionInput(ClientPtr client);
void
SXFixesSelectionNotifyEvent (xXFixesSelectionNotifyEvent *from,
xXFixesSelectionNotifyEvent *to);
SXFixesSelectionNotifyEvent(xXFixesSelectionNotifyEvent * from,
xXFixesSelectionNotifyEvent * to);
Bool
XFixesSelectionInit (void);
XFixesSelectionInit(void);
/* Cursor notification */
Bool
XFixesCursorInit (void);
int
ProcXFixesSelectCursorInput (ClientPtr client);
XFixesCursorInit(void);
int
SProcXFixesSelectCursorInput (ClientPtr client);
ProcXFixesSelectCursorInput(ClientPtr client);
int
SProcXFixesSelectCursorInput(ClientPtr client);
void
SXFixesCursorNotifyEvent (xXFixesCursorNotifyEvent *from,
xXFixesCursorNotifyEvent *to);
SXFixesCursorNotifyEvent(xXFixesCursorNotifyEvent * from,
xXFixesCursorNotifyEvent * to);
int
ProcXFixesGetCursorImage (ClientPtr client);
ProcXFixesGetCursorImage(ClientPtr client);
int
SProcXFixesGetCursorImage (ClientPtr client);
SProcXFixesGetCursorImage(ClientPtr client);
/* Cursor names (Version 2) */
int
ProcXFixesSetCursorName (ClientPtr client);
ProcXFixesSetCursorName(ClientPtr client);
int
SProcXFixesSetCursorName (ClientPtr client);
SProcXFixesSetCursorName(ClientPtr client);
int
ProcXFixesGetCursorName (ClientPtr client);
ProcXFixesGetCursorName(ClientPtr client);
int
SProcXFixesGetCursorName (ClientPtr client);
SProcXFixesGetCursorName(ClientPtr client);
int
ProcXFixesGetCursorImageAndName (ClientPtr client);
ProcXFixesGetCursorImageAndName(ClientPtr client);
int
SProcXFixesGetCursorImageAndName (ClientPtr client);
SProcXFixesGetCursorImageAndName(ClientPtr client);
/* Cursor replacement (Version 2) */
int
ProcXFixesChangeCursor (ClientPtr client);
ProcXFixesChangeCursor(ClientPtr client);
int
SProcXFixesChangeCursor (ClientPtr client);
SProcXFixesChangeCursor(ClientPtr client);
int
ProcXFixesChangeCursorByName (ClientPtr client);
ProcXFixesChangeCursorByName(ClientPtr client);
int
SProcXFixesChangeCursorByName (ClientPtr client);
SProcXFixesChangeCursorByName(ClientPtr client);
/* Region objects (Version 2* */
Bool
XFixesRegionInit (void);
XFixesRegionInit(void);
int
ProcXFixesCreateRegion (ClientPtr client);
ProcXFixesCreateRegion(ClientPtr client);
int
SProcXFixesCreateRegion (ClientPtr client);
SProcXFixesCreateRegion(ClientPtr client);
int
ProcXFixesCreateRegionFromBitmap (ClientPtr client);
ProcXFixesCreateRegionFromBitmap(ClientPtr client);
int
SProcXFixesCreateRegionFromBitmap (ClientPtr client);
SProcXFixesCreateRegionFromBitmap(ClientPtr client);
int
ProcXFixesCreateRegionFromWindow (ClientPtr client);
ProcXFixesCreateRegionFromWindow(ClientPtr client);
int
SProcXFixesCreateRegionFromWindow (ClientPtr client);
SProcXFixesCreateRegionFromWindow(ClientPtr client);
int
ProcXFixesCreateRegionFromGC (ClientPtr client);
ProcXFixesCreateRegionFromGC(ClientPtr client);
int
SProcXFixesCreateRegionFromGC (ClientPtr client);
SProcXFixesCreateRegionFromGC(ClientPtr client);
int
ProcXFixesCreateRegionFromPicture (ClientPtr client);
ProcXFixesCreateRegionFromPicture(ClientPtr client);
int
SProcXFixesCreateRegionFromPicture (ClientPtr client);
SProcXFixesCreateRegionFromPicture(ClientPtr client);
int
ProcXFixesDestroyRegion (ClientPtr client);
ProcXFixesDestroyRegion(ClientPtr client);
int
SProcXFixesDestroyRegion (ClientPtr client);
SProcXFixesDestroyRegion(ClientPtr client);
int
ProcXFixesSetRegion (ClientPtr client);
ProcXFixesSetRegion(ClientPtr client);
int
SProcXFixesSetRegion (ClientPtr client);
SProcXFixesSetRegion(ClientPtr client);
int
ProcXFixesCopyRegion (ClientPtr client);
ProcXFixesCopyRegion(ClientPtr client);
int
SProcXFixesCopyRegion (ClientPtr client);
SProcXFixesCopyRegion(ClientPtr client);
int
ProcXFixesCombineRegion (ClientPtr client);
ProcXFixesCombineRegion(ClientPtr client);
int
SProcXFixesCombineRegion (ClientPtr client);
SProcXFixesCombineRegion(ClientPtr client);
int
ProcXFixesInvertRegion (ClientPtr client);
ProcXFixesInvertRegion(ClientPtr client);
int
SProcXFixesInvertRegion (ClientPtr client);
SProcXFixesInvertRegion(ClientPtr client);
int
ProcXFixesTranslateRegion (ClientPtr client);
ProcXFixesTranslateRegion(ClientPtr client);
int
SProcXFixesTranslateRegion (ClientPtr client);
SProcXFixesTranslateRegion(ClientPtr client);
int
ProcXFixesRegionExtents (ClientPtr client);
ProcXFixesRegionExtents(ClientPtr client);
int
SProcXFixesRegionExtents (ClientPtr client);
SProcXFixesRegionExtents(ClientPtr client);
int
ProcXFixesFetchRegion (ClientPtr client);
ProcXFixesFetchRegion(ClientPtr client);
int
SProcXFixesFetchRegion (ClientPtr client);
SProcXFixesFetchRegion(ClientPtr client);
int
ProcXFixesSetGCClipRegion (ClientPtr client);
ProcXFixesSetGCClipRegion(ClientPtr client);
int
SProcXFixesSetGCClipRegion (ClientPtr client);
SProcXFixesSetGCClipRegion(ClientPtr client);
int
ProcXFixesSetWindowShapeRegion (ClientPtr client);
ProcXFixesSetWindowShapeRegion(ClientPtr client);
int
SProcXFixesSetWindowShapeRegion (ClientPtr client);
SProcXFixesSetWindowShapeRegion(ClientPtr client);
int
ProcXFixesSetPictureClipRegion (ClientPtr client);
ProcXFixesSetPictureClipRegion(ClientPtr client);
int
SProcXFixesSetPictureClipRegion (ClientPtr client);
SProcXFixesSetPictureClipRegion(ClientPtr client);
int
ProcXFixesExpandRegion (ClientPtr client);
ProcXFixesExpandRegion(ClientPtr client);
int
SProcXFixesExpandRegion (ClientPtr client);
SProcXFixesExpandRegion(ClientPtr client);
int
PanoramiXFixesSetGCClipRegion (ClientPtr client);
PanoramiXFixesSetGCClipRegion(ClientPtr client);
int
PanoramiXFixesSetWindowShapeRegion (ClientPtr client);
PanoramiXFixesSetWindowShapeRegion(ClientPtr client);
int
PanoramiXFixesSetPictureClipRegion (ClientPtr client);
PanoramiXFixesSetPictureClipRegion(ClientPtr client);
/* Cursor Visibility (Version 4) */
int
ProcXFixesHideCursor (ClientPtr client);
int
ProcXFixesHideCursor(ClientPtr client);
int
SProcXFixesHideCursor (ClientPtr client);
int
SProcXFixesHideCursor(ClientPtr client);
int
ProcXFixesShowCursor (ClientPtr client);
int
ProcXFixesShowCursor(ClientPtr client);
int
SProcXFixesShowCursor (ClientPtr client);
int
SProcXFixesShowCursor(ClientPtr client);
/* Version 5 */
int
ProcXFixesCreatePointerBarrier (ClientPtr client);
ProcXFixesCreatePointerBarrier(ClientPtr client);
int
SProcXFixesCreatePointerBarrier (ClientPtr client);
SProcXFixesCreatePointerBarrier(ClientPtr client);
int
ProcXFixesDestroyPointerBarrier (ClientPtr client);
ProcXFixesDestroyPointerBarrier(ClientPtr client);
int
SProcXFixesDestroyPointerBarrier (ClientPtr client);
SProcXFixesDestroyPointerBarrier(ClientPtr client);
/* Xinerama */
extern int (*PanoramiXSaveXFixesVector[XFixesNumberRequests])(ClientPtr);
void PanoramiXFixesInit (void);
void PanoramiXFixesReset (void);
extern int (*PanoramiXSaveXFixesVector[XFixesNumberRequests]) (ClientPtr);
void PanoramiXFixesInit(void);
void PanoramiXFixesReset(void);
#endif /* _XFIXESINT_H_ */
#endif /* _XFIXESINT_H_ */