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

Merge branch 'master' into XACE-SELINUX

Browse Source
This commit is contained in:
Eamon Walsh 2007-03-26 10:28:05 -04:00 committed by Eamon Walsh
commit 0331c6a8fc
240 changed files with 5915 additions and 6801 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
GL/glx/glxdri.c
View File

@ -495,6 +495,7 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
context->base.loseCurrent = __glXDRIcontextLoseCurrent;
context->base.copy = __glXDRIcontextCopy;
context->base.forceCurrent = __glXDRIcontextForceCurrent;
context->base.pScreen = screen->base.pScreen;
context->base.textureFromPixmap = &__glXDRItextureFromPixmap;

52
Xext/appgroup.c
View File

@ -116,8 +116,7 @@ int XagAppGroupFree(
return Success;
}
/* static */
void XagClientStateChange(
static void XagClientStateChange(
CallbackListPtr* pcbl,
pointer nulldata,
pointer calldata)
@ -172,21 +171,6 @@ void XagClientStateChange(
}
}
void
XagExtensionInit(INITARGS)
{
if (AddExtension (XAGNAME,
0,
XagNumberErrors,
ProcXagDispatch,
SProcXagDispatch,
XagResetProc,
StandardMinorOpcode)) {
RT_APPGROUP = CreateNewResourceType (XagAppGroupFree);
XaceRegisterCallback(XACE_AUTH_AVAIL, XagCallClientStateChange, NULL);
}
}
/*ARGSUSED*/
static
void XagResetProc(
@ -393,8 +377,7 @@ int AttrValidate(
return client->noClientException;
}
/* static */
int ProcXagCreate (
static int ProcXagCreate (
register ClientPtr client)
{
REQUEST (xXagCreateReq);
@ -425,8 +408,7 @@ int ProcXagCreate (
return client->noClientException;
}
/* static */
int ProcXagDestroy(
static int ProcXagDestroy(
register ClientPtr client)
{
AppGroupPtr pAppGrp;
@ -743,18 +725,7 @@ XID XagId(
return (client->appgroup ? client->appgroup->appgroupId : 0);
}
void XagGetDeltaInfo(
ClientPtr client,
CARD32* buf)
{
*buf++ = (CARD32) client->appgroup->default_root;
*buf++ = (CARD32) client->appgroup->root_visual;
*buf++ = (CARD32) client->appgroup->default_colormap;
*buf++ = (CARD32) client->appgroup->black_pixel;
*buf = (CARD32) client->appgroup->white_pixel;
}
void XagCallClientStateChange(
static void XagCallClientStateChange(
CallbackListPtr *pcbl,
pointer nulldata,
pointer calldata)
@ -785,3 +756,18 @@ void XagCallClientStateChange(
XagClientStateChange (NULL, NULL, (pointer)&clientinfo);
}
}
void
XagExtensionInit(INITARGS)
{
if (AddExtension (XAGNAME,
0,
XagNumberErrors,
ProcXagDispatch,
SProcXagDispatch,
XagResetProc,
StandardMinorOpcode)) {
RT_APPGROUP = CreateNewResourceType (XagAppGroupFree);
XaceRegisterCallback(XACE_AUTH_AVAIL, XagCallClientStateChange, NULL);
}
}

22
Xext/appgroup.h
View File

@ -50,12 +50,6 @@ extern ClientPtr XagLeader(
ClientPtr /* client */
);
extern void XagCallClientStateChange(
CallbackListPtr * /* pcbl */,
pointer /* nulldata */,
pointer /* calldata */
);
extern Bool XagIsControlledRoot (
ClientPtr /* client */,
WindowPtr /* pParent */
@ -65,22 +59,6 @@ extern XID XagId (
ClientPtr /* client */
);
extern void XagGetDeltaInfo (
ClientPtr /* client */,
CARD32* /* buf */
);
extern void XagClientStateChange(
CallbackListPtr* pcbl,
pointer nulldata,
pointer calldata);
extern int ProcXagCreate (
register ClientPtr client);
extern int ProcXagDestroy(
register ClientPtr client);
_XFUNCPROTOEND
#endif /* _APPGROUP_SRV_H_ */

48
Xext/panoramiX.c
View File

@ -77,7 +77,7 @@ int PanoramiXPixHeight = 0;
_X_EXPORT int PanoramiXNumScreens = 0;
_X_EXPORT PanoramiXData *panoramiXdataPtr = NULL;
RegionRec PanoramiXScreenRegion = {{0, 0, 0, 0}, NULL};
static RegionRec PanoramiXScreenRegion = {{0, 0, 0, 0}, NULL};
static int PanoramiXNumDepths;
static DepthPtr PanoramiXDepths;
@ -109,7 +109,6 @@ static void PanoramiXResetProc(ExtensionEntry*);
#include "panoramiXh.h"
int (* SavedProcVector[256]) (ClientPtr client) = { NULL, };
ScreenInfo *GlobalScrInfo = NULL;
static int PanoramiXGCIndex = -1;
static int PanoramiXScreenIndex = -1;
@ -135,7 +134,7 @@ static void XineramaChangeClip(GCPtr, int, pointer, int);
static void XineramaDestroyClip(GCPtr);
static void XineramaCopyClip(GCPtr, GCPtr);
GCFuncs XineramaGCFuncs = {
static GCFuncs XineramaGCFuncs = {
XineramaValidateGC, XineramaChangeGC, XineramaCopyGC, XineramaDestroyGC,
XineramaChangeClip, XineramaDestroyClip, XineramaCopyClip
};
@ -168,7 +167,7 @@ XineramaCloseScreen (int i, ScreenPtr pScreen)
return (*pScreen->CloseScreen) (i, pScreen);
}
Bool
static Bool
XineramaCreateGC(GCPtr pGC)
{
ScreenPtr pScreen = pGC->pScreen;
@ -330,8 +329,6 @@ XineramaDestroyClip(GCPtr pGC)
Xinerama_GC_FUNC_EPILOGUE (pGC);
}
_X_EXPORT int
XineramaDeleteResource(pointer data, XID id)
{
@ -339,32 +336,11 @@ XineramaDeleteResource(pointer data, XID id)
return 1;
}
static Bool
XineramaFindIDOnAnyScreen(pointer resource, XID id, pointer privdata)
{
PanoramiXRes *res = (PanoramiXRes*)resource;
int j;
FOR_NSCREENS(j)
if(res->info[j].id == *((XID*)privdata)) return TRUE;
return FALSE;
}
PanoramiXRes *
PanoramiXFindIDOnAnyScreen(RESTYPE type, XID id)
{
return LookupClientResourceComplex(clients[CLIENT_ID(id)], type,
XineramaFindIDOnAnyScreen, &id);
}
typedef struct {
int screen;
int id;
} PanoramiXSearchData;
static Bool
XineramaFindIDByScrnum(pointer resource, XID id, pointer privdata)
{
@ -389,23 +365,6 @@ PanoramiXFindIDByScrnum(RESTYPE type, XID id, int screen)
XineramaFindIDByScrnum, &data);
}
WindowPtr
PanoramiXChangeWindow(int ScrnNum, WindowPtr pWin)
{
int num = pWin->drawable.pScreen->myNum;
if(num != ScrnNum) {
PanoramiXRes *win;
win = PanoramiXFindIDByScrnum(XRT_WINDOW, pWin->drawable.id, num);
if (win)
pWin = (WindowPtr) LookupIDByType(win->info[ScrnNum].id, RT_WINDOW);
}
return pWin;
}
typedef struct _connect_callback_list {
void (*func)(void);
struct _connect_callback_list *next;
@ -496,7 +455,6 @@ void PanoramiXExtensionInit(int argc, char *argv[])
if (noPanoramiXExtension)
return;
GlobalScrInfo = &screenInfo; /* For debug visibility */
PanoramiXNumScreens = screenInfo.numScreens;
if (PanoramiXNumScreens == 1) { /* Only 1 screen */
noPanoramiXExtension = TRUE;

12
Xext/panoramiX.h
View File

@ -94,18 +94,6 @@ typedef struct {
(a).root = WindowTable[0]->drawable.id; \
}
#define FORCE_WIN(a) { \
if ((win = PanoramiXFindIDOnAnyScreen(XRT_WINDOW, a))) { \
(a) = win->info[0].id; /* Real ID */ \
} \
}
#define FORCE_CMAP(a) { \
if ((win = PanoramiXFindIDOnAnyScreen(XRT_COLORMAP, a))) { \
(a) = win->info[0].id; /* Real ID */ \
} \
}
#define IS_SHARED_PIXMAP(r) (((r)->type == XRT_PIXMAP) && (r)->u.pix.shared)
#define SKIP_FAKE_WINDOW(a) if(!LookupIDByType(a, XRT_WINDOW)) return

5
Xext/panoramiXh.h
View File

@ -19,10 +19,10 @@ extern int PanoramiXGetGeometry(ClientPtr client);
extern int PanoramiXTranslateCoords(ClientPtr client);
extern int PanoramiXCreatePixmap(ClientPtr client);
extern int PanoramiXFreePixmap(ClientPtr client);
extern int PanoramiXCreateGC(ClientPtr client);
extern int PanoramiXChangeGC(ClientPtr client);
extern int PanoramiXCopyGC(ClientPtr client);
extern int PanoramiXCopyColormapAndFree(ClientPtr client);
extern int PanoramiXCreateGC(ClientPtr client);
extern int PanoramiXSetDashes(ClientPtr client);
extern int PanoramiXSetClipRectangles(ClientPtr client);
extern int PanoramiXFreeGC(ClientPtr client);
@ -64,7 +64,6 @@ PROC_EXTERN(ProcPanoramiXGetScreenSize);
PROC_EXTERN(ProcXineramaQueryScreens);
PROC_EXTERN(ProcXineramaIsActive);
extern Bool XineramaCreateGC(GCPtr pGC);
extern int SProcPanoramiXDispatch(ClientPtr client);
@ -72,6 +71,4 @@ extern char *ConnectionInfo;
extern int connBlockScreenStart;
extern xConnSetupPrefix connSetupPrefix;
extern ScreenInfo *GlobalScrInfo;
extern int (* SavedProcVector[256]) (ClientPtr client);

3
Xext/panoramiXsrv.h
View File

@ -12,14 +12,11 @@ extern int PanoramiXNumScreens;
extern PanoramiXData *panoramiXdataPtr;
extern int PanoramiXPixWidth;
extern int PanoramiXPixHeight;
extern RegionRec PanoramiXScreenRegion;
extern XID *PanoramiXVisualTable;
extern void PanoramiXConsolidate(void);
extern Bool PanoramiXCreateConnectionBlock(void);
extern PanoramiXRes * PanoramiXFindIDByScrnum(RESTYPE, XID, int);
extern PanoramiXRes * PanoramiXFindIDOnAnyScreen(RESTYPE, XID);
extern WindowPtr PanoramiXChangeWindow(int, WindowPtr);
extern Bool XineramaRegisterConnectionBlockCallback(void (*func)(void));
extern int XineramaDeleteResource(pointer, XID);

4
Xext/saver.c
View File

@ -66,7 +66,7 @@ static unsigned char ScreenSaverReqCode = 0;
#endif
static int ScreenSaverEventBase = 0;
extern DISPATCH_PROC(ProcScreenSaverQueryInfo);
static DISPATCH_PROC(ProcScreenSaverQueryInfo);
static DISPATCH_PROC(ProcScreenSaverDispatch);
static DISPATCH_PROC(ProcScreenSaverQueryVersion);
static DISPATCH_PROC(ProcScreenSaverSelectInput);
@ -774,7 +774,7 @@ ProcScreenSaverQueryVersion (client)
return (client->noClientException);
}
int
static int
ProcScreenSaverQueryInfo (client)
register ClientPtr client;
{

2
Xext/security.c
View File

@ -71,7 +71,7 @@ typedef struct {
#define AUTHID(client) \
(((SecurityClientStateRec*)STATEPTR(client))->authId)
CallbackListPtr SecurityValidateGroupCallback = NULL; /* see security.h */
static CallbackListPtr SecurityValidateGroupCallback = NULL;
RESTYPE SecurityAuthorizationResType; /* resource type for authorizations */

9
Xext/securitysrv.h
View File

@ -72,15 +72,6 @@ typedef struct {
struct _OtherClients *eventClients; /* clients wanting events */
} SecurityAuthorizationRec, *SecurityAuthorizationPtr;
/* The following callback is called when a GenerateAuthorization request
* is processed to sanity check the group argument. The call data will
* be a pointer to a SecurityValidateGroupInfoRec (below).
* Functions registered on this callback are expected to examine the
* group and set the valid field to TRUE if they recognize the group as a
* legitimate group. If they don't recognize it, they should not change the
* valid field.
*/
extern CallbackListPtr SecurityValidateGroupCallback;
typedef struct {
XID group; /* the group that was sent in GenerateAuthorization */
Bool valid; /* did anyone recognize it? if so, set to TRUE */

4
Xext/xace.c
View File

@ -35,10 +35,10 @@ CallbackListPtr XaceHooks[XACE_NUM_HOOKS] = {0};
* from guessing extension major opcodes and using the extension even though
* the extension can't be listed or queried.
*/
int (*UntrustedProcVector[256])(
static int (*UntrustedProcVector[256])(
ClientPtr /*client*/
);
int (*SwappedUntrustedProcVector[256])(
static int (*SwappedUntrustedProcVector[256])(
ClientPtr /*client*/
);

10
Xext/xace.h
View File

@ -82,16 +82,6 @@ extern int XaceHook(
/* From the original Security extension...
*/
/* Proc vectors for untrusted clients, swapped and unswapped versions.
* These are the same as the normal proc vectors except that extensions
* that haven't declared themselves secure will have ProcBadRequest plugged
* in for their major opcode dispatcher. This prevents untrusted clients
* from guessing extension major opcodes and using the extension even though
* the extension can't be listed or queried.
*/
extern int (*UntrustedProcVector[256])(ClientPtr client);
extern int (*SwappedUntrustedProcVector[256])(ClientPtr client);
extern void XaceCensorImage(
ClientPtr client,
RegionPtr pVisibleRegion,

4
Xext/xevie.c
View File

@ -52,7 +52,7 @@ of the copyright holder.
#include "inputstr.h"
#include "windowstr.h"
#include "cursorstr.h"
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#include "../os/osdep.h"
@ -105,7 +105,7 @@ typedef struct {
} xevieKeycQueueRec, *xevieKeycQueuePtr;
#define KEYC_QUEUE_SIZE 100
xevieKeycQueueRec keycq[KEYC_QUEUE_SIZE] = {{0, NULL}};
static xevieKeycQueueRec keycq[KEYC_QUEUE_SIZE] = {{0, NULL}};
static int keycqHead = 0, keycqTail = 0;
static int ProcDispatch (ClientPtr), SProcDispatch (ClientPtr);

261
Xi/chgfctl.c
View File

@ -89,137 +89,13 @@ SProcXChangeFeedbackControl(register ClientPtr client)
return (ProcXChangeFeedbackControl(client));
}
/***********************************************************************
*
* Change the control attributes.
*
*/
int
ProcXChangeFeedbackControl(ClientPtr client)
{
unsigned len;
DeviceIntPtr dev;
KbdFeedbackPtr k;
PtrFeedbackPtr p;
IntegerFeedbackPtr i;
StringFeedbackPtr s;
BellFeedbackPtr b;
LedFeedbackPtr l;
REQUEST(xChangeFeedbackControlReq);
REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
len = stuff->length - (sizeof(xChangeFeedbackControlReq) >> 2);
dev = LookupDeviceIntRec(stuff->deviceid);
if (dev == NULL) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
BadDevice);
return Success;
}
switch (stuff->feedbackid) {
case KbdFeedbackClass:
if (len != (sizeof(xKbdFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (k = dev->kbdfeed; k; k = k->next)
if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id) {
ChangeKbdFeedback(client, dev, stuff->mask, k,
(xKbdFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case PtrFeedbackClass:
if (len != (sizeof(xPtrFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (p = dev->ptrfeed; p; p = p->next)
if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id) {
ChangePtrFeedback(client, dev, stuff->mask, p,
(xPtrFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case StringFeedbackClass:
{
register char n;
xStringFeedbackCtl *f = ((xStringFeedbackCtl *) & stuff[1]);
if (client->swapped) {
swaps(&f->num_keysyms, n);
}
if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (s = dev->stringfeed; s; s = s->next)
if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id) {
ChangeStringFeedback(client, dev, stuff->mask, s,
(xStringFeedbackCtl *) & stuff[1]);
return Success;
}
break;
}
case IntegerFeedbackClass:
if (len != (sizeof(xIntegerFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (i = dev->intfeed; i; i = i->next)
if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id) {
ChangeIntegerFeedback(client, dev, stuff->mask, i,
(xIntegerFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case LedFeedbackClass:
if (len != (sizeof(xLedFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (l = dev->leds; l; l = l->next)
if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id) {
ChangeLedFeedback(client, dev, stuff->mask, l,
(xLedFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case BellFeedbackClass:
if (len != (sizeof(xBellFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (b = dev->bell; b; b = b->next)
if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id) {
ChangeBellFeedback(client, dev, stuff->mask, b,
(xBellFeedbackCtl *) & stuff[1]);
return Success;
}
break;
default:
break;
}
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
return Success;
}
/******************************************************************************
*
* This procedure changes KbdFeedbackClass data.
*
*/
int
static int
ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
KbdFeedbackPtr k, xKbdFeedbackCtl * f)
{
@ -351,7 +227,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
*
*/
int
static int
ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
PtrFeedbackPtr p, xPtrFeedbackCtl * f)
{
@ -422,7 +298,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
*
*/
int
static int
ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
long unsigned int mask, IntegerFeedbackPtr i,
xIntegerFeedbackCtl * f)
@ -445,7 +321,7 @@ ChangeIntegerFeedback(ClientPtr client, DeviceIntPtr dev,
*
*/
int
static int
ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
long unsigned int mask, StringFeedbackPtr s,
xStringFeedbackCtl * f)
@ -495,7 +371,7 @@ ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
*
*/
int
static int
ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
long unsigned int mask, BellFeedbackPtr b,
xBellFeedbackCtl * f)
@ -560,7 +436,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
*
*/
int
static int
ChangeLedFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
LedFeedbackPtr l, xLedFeedbackCtl * f)
{
@ -585,3 +461,128 @@ ChangeLedFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
return Success;
}
/***********************************************************************
*
* Change the control attributes.
*
*/
int
ProcXChangeFeedbackControl(ClientPtr client)
{
unsigned len;
DeviceIntPtr dev;
KbdFeedbackPtr k;
PtrFeedbackPtr p;
IntegerFeedbackPtr i;
StringFeedbackPtr s;
BellFeedbackPtr b;
LedFeedbackPtr l;
REQUEST(xChangeFeedbackControlReq);
REQUEST_AT_LEAST_SIZE(xChangeFeedbackControlReq);
len = stuff->length - (sizeof(xChangeFeedbackControlReq) >> 2);
dev = LookupDeviceIntRec(stuff->deviceid);
if (dev == NULL) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
BadDevice);
return Success;
}
switch (stuff->feedbackid) {
case KbdFeedbackClass:
if (len != (sizeof(xKbdFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (k = dev->kbdfeed; k; k = k->next)
if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id) {
ChangeKbdFeedback(client, dev, stuff->mask, k,
(xKbdFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case PtrFeedbackClass:
if (len != (sizeof(xPtrFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (p = dev->ptrfeed; p; p = p->next)
if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id) {
ChangePtrFeedback(client, dev, stuff->mask, p,
(xPtrFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case StringFeedbackClass:
{
register char n;
xStringFeedbackCtl *f = ((xStringFeedbackCtl *) & stuff[1]);
if (client->swapped) {
swaps(&f->num_keysyms, n);
}
if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (s = dev->stringfeed; s; s = s->next)
if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id) {
ChangeStringFeedback(client, dev, stuff->mask, s,
(xStringFeedbackCtl *) & stuff[1]);
return Success;
}
break;
}
case IntegerFeedbackClass:
if (len != (sizeof(xIntegerFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (i = dev->intfeed; i; i = i->next)
if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id) {
ChangeIntegerFeedback(client, dev, stuff->mask, i,
(xIntegerFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case LedFeedbackClass:
if (len != (sizeof(xLedFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (l = dev->leds; l; l = l->next)
if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id) {
ChangeLedFeedback(client, dev, stuff->mask, l,
(xLedFeedbackCtl *) & stuff[1]);
return Success;
}
break;
case BellFeedbackClass:
if (len != (sizeof(xBellFeedbackCtl) >> 2)) {
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
0, BadLength);
return Success;
}
for (b = dev->bell; b; b = b->next)
if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id) {
ChangeBellFeedback(client, dev, stuff->mask, b,
(xBellFeedbackCtl *) & stuff[1]);
return Success;
}
break;
default:
break;
}
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
return Success;
}

42
Xi/chgfctl.h
View File

@ -36,46 +36,4 @@ int SProcXChangeFeedbackControl(ClientPtr /* client */
int ProcXChangeFeedbackControl(ClientPtr /* client */
);
int ChangeKbdFeedback(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
unsigned long /* mask */ ,
KbdFeedbackPtr /* k */ ,
xKbdFeedbackCtl * /* f */
);
int ChangePtrFeedback(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
unsigned long /* mask */ ,
PtrFeedbackPtr /* p */ ,
xPtrFeedbackCtl * /* f */
);
int ChangeIntegerFeedback(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
unsigned long /* mask */ ,
IntegerFeedbackPtr /* i */ ,
xIntegerFeedbackCtl * /* f */
);
int ChangeStringFeedback(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
unsigned long /* mask */ ,
StringFeedbackPtr /* s */ ,
xStringFeedbackCtl * /* f */
);
int ChangeBellFeedback(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
unsigned long /* mask */ ,
BellFeedbackPtr /* b */ ,
xBellFeedbackCtl * /* f */
);
int ChangeLedFeedback(ClientPtr /* client */ ,
DeviceIntPtr /* dev */ ,
unsigned long /* mask */ ,
LedFeedbackPtr /* l */ ,
xLedFeedbackCtl * /* f */
);
#endif /* CHGFCTL_H */

8
Xi/chgptr.h
View File

@ -45,12 +45,4 @@ void SendEventToAllWindows(DeviceIntPtr /* dev */ ,
int /* count */
);
void FindInterestedChildren( /* FIXME: could be static? */
DeviceIntPtr /* dev */ ,
WindowPtr /* p1 */ ,
Mask /* mask */ ,
xEvent * /* ev */ ,
int /* count */
);
#endif /* CHGPTR_H */

94
Xi/closedev.c
View File

@ -87,6 +87,53 @@ SProcXCloseDevice(register ClientPtr client)
return (ProcXCloseDevice(client));
}
/***********************************************************************
*
* Clear out event selections and passive grabs from a window for the
* specified device.
*
*/
static void
DeleteDeviceEvents(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
{
InputClientsPtr others;
OtherInputMasks *pOthers;
GrabPtr grab, next;
if ((pOthers = wOtherInputMasks(pWin)) != 0)
for (others = pOthers->inputClients; others; others = others->next)
if (SameClient(others, client))
others->mask[dev->id] = NoEventMask;
for (grab = wPassiveGrabs(pWin); grab; grab = next) {
next = grab->next;
if ((grab->device == dev) &&
(client->clientAsMask == CLIENT_BITS(grab->resource)))
FreeResource(grab->resource, RT_NONE);
}
}
/***********************************************************************
*
* Walk througth the window tree, deleting event selections for this client
* from this device from all windows.
*
*/
static void
DeleteEventsFromChildren(DeviceIntPtr dev, WindowPtr p1, ClientPtr client)
{
WindowPtr p2;
while (p1) {
p2 = p1->firstChild;
DeleteDeviceEvents(dev, p1, client);
DeleteEventsFromChildren(dev, p2, client);
p1 = p1->nextSib;
}
}
/***********************************************************************
*
* This procedure closes an input device.
@ -126,50 +173,3 @@ ProcXCloseDevice(register ClientPtr client)
CloseInputDevice(d, client);
return Success;
}
/***********************************************************************
*
* Walk througth the window tree, deleting event selections for this client
* from this device from all windows.
*
*/
void
DeleteEventsFromChildren(DeviceIntPtr dev, WindowPtr p1, ClientPtr client)
{
WindowPtr p2;
while (p1) {
p2 = p1->firstChild;
DeleteDeviceEvents(dev, p1, client);
DeleteEventsFromChildren(dev, p2, client);
p1 = p1->nextSib;
}
}
/***********************************************************************
*
* Clear out event selections and passive grabs from a window for the
* specified device.
*
*/
void
DeleteDeviceEvents(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
{
InputClientsPtr others;
OtherInputMasks *pOthers;
GrabPtr grab, next;
if ((pOthers = wOtherInputMasks(pWin)) != 0)
for (others = pOthers->inputClients; others; others = others->next)
if (SameClient(others, client))
others->mask[dev->id] = NoEventMask;
for (grab = wPassiveGrabs(pWin); grab; grab = next) {
next = grab->next;
if ((grab->device == dev) &&
(client->clientAsMask == CLIENT_BITS(grab->resource)))
FreeResource(grab->resource, RT_NONE);
}
}

10
Xi/closedev.h
View File

@ -36,14 +36,4 @@ int SProcXCloseDevice(ClientPtr /* client */
int ProcXCloseDevice(ClientPtr /* client */
);
void DeleteEventsFromChildren(DeviceIntPtr /* dev */ ,
WindowPtr /* p1 */ ,
ClientPtr /* client */
);
void DeleteDeviceEvents(DeviceIntPtr /* dev */ ,
WindowPtr /* pWin */ ,
ClientPtr /* client */
);
#endif /* CLOSEDEV_H */

58
Xi/exevents.c
View File

@ -994,33 +994,7 @@ ChangeKeyMapping(ClientPtr client,
return client->noClientException;
}
void
DeleteWindowFromAnyExtEvents(WindowPtr pWin, Bool freeResources)
{
int i;
DeviceIntPtr dev;
InputClientsPtr ic;
struct _OtherInputMasks *inputMasks;
for (dev = inputInfo.devices; dev; dev = dev->next) {
if (dev == inputInfo.pointer || dev == inputInfo.keyboard)
continue;
DeleteDeviceFromAnyExtEvents(pWin, dev);
}
for (dev = inputInfo.off_devices; dev; dev = dev->next)
DeleteDeviceFromAnyExtEvents(pWin, dev);
if (freeResources)
while ((inputMasks = wOtherInputMasks(pWin)) != 0) {
ic = inputMasks->inputClients;
for (i = 0; i < EMASKSIZE; i++)
inputMasks->dontPropagateMask[i] = 0;
FreeResource(ic->resource, RT_NONE);
}
}
void
static void
DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
{
WindowPtr parent;
@ -1085,6 +1059,32 @@ DeleteDeviceFromAnyExtEvents(WindowPtr pWin, DeviceIntPtr dev)
dev->valuator->motionHintWindow = NullWindow;
}
void
DeleteWindowFromAnyExtEvents(WindowPtr pWin, Bool freeResources)
{
int i;
DeviceIntPtr dev;
InputClientsPtr ic;
struct _OtherInputMasks *inputMasks;
for (dev = inputInfo.devices; dev; dev = dev->next) {
if (dev == inputInfo.pointer || dev == inputInfo.keyboard)
continue;
DeleteDeviceFromAnyExtEvents(pWin, dev);
}
for (dev = inputInfo.off_devices; dev; dev = dev->next)
DeleteDeviceFromAnyExtEvents(pWin, dev);
if (freeResources)
while ((inputMasks = wOtherInputMasks(pWin)) != 0) {
ic = inputMasks->inputClients;
for (i = 0; i < EMASKSIZE; i++)
inputMasks->dontPropagateMask[i] = 0;
FreeResource(ic->resource, RT_NONE);
}
}
int
MaybeSendDeviceMotionNotifyHint(deviceKeyButtonPointer * pEvents, Mask mask)
{
@ -1138,7 +1138,7 @@ CheckDeviceGrabAndHintWindow(WindowPtr pWin, int type,
}
}
Mask
static Mask
DeviceEventMaskForClient(DeviceIntPtr dev, WindowPtr pWin, ClientPtr client)
{
register InputClientsPtr other;
@ -1223,7 +1223,7 @@ ShouldFreeInputMasks(WindowPtr pWin, Bool ignoreSelectedEvents)
*
*/
void
static void
FindInterestedChildren(DeviceIntPtr dev, WindowPtr p1, Mask mask,
xEvent * ev, int count)
{

2
Xi/exglobals.h
View File

@ -37,7 +37,6 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
extern int IReqCode;
extern int BadDevice;
extern int BadEvent;
extern int BadMode;
extern int DeviceBusy;
extern int BadClass;
@ -46,7 +45,6 @@ extern Mask DevicePointerMotionMask;
extern Mask DevicePointerMotionHintMask;
extern Mask DeviceFocusChangeMask;
extern Mask DeviceStateNotifyMask;
extern Mask ChangeDeviceNotifyMask;
extern Mask DeviceMappingNotifyMask;
extern Mask DeviceOwnerGrabButtonMask;
extern Mask DeviceButtonGrabMask;

386
Xi/extinit.c
View File

@ -116,7 +116,7 @@ int ExtEventIndex;
Mask ExtValidMasks[EMASKSIZE];
Mask ExtExclusiveMasks[EMASKSIZE];
struct dev_type
static struct dev_type
{
Atom type;
char *name;
@ -152,7 +152,7 @@ XExtEventInfo EventInfo[32];
int IReqCode = 0;
int BadDevice = 0;
int BadEvent = 1;
static int BadEvent = 1;
int BadMode = 2;
int DeviceBusy = 3;
int BadClass = 4;
@ -161,7 +161,7 @@ Mask DevicePointerMotionMask;
Mask DevicePointerMotionHintMask;
Mask DeviceFocusChangeMask;
Mask DeviceStateNotifyMask;
Mask ChangeDeviceNotifyMask;
static Mask ChangeDeviceNotifyMask;
Mask DeviceMappingNotifyMask;
Mask DeviceOwnerGrabButtonMask;
Mask DeviceButtonGrabMask;
@ -208,51 +208,6 @@ static XExtensionVersion thisversion = { XI_Present,
XI_Add_DevicePresenceNotify_Minor
};
/**********************************************************************
*
* IExtensionInit - initialize the input extension.
*
* Called from InitExtensions in main() or from QueryExtension() if the
* extension is dynamically loaded.
*
* This extension has several events and errors.
*
*/
void
XInputExtensionInit(void)
{
ExtensionEntry *extEntry;
extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
SProcIDispatch, IResetProc, StandardMinorOpcode);
if (extEntry) {
IReqCode = extEntry->base;
AllExtensionVersions[IReqCode - 128] = thisversion;
MakeDeviceTypeAtoms();
RT_INPUTCLIENT = CreateNewResourceType((DeleteType) InputClientGone);
FixExtensionEvents(extEntry);
ReplySwapVector[IReqCode] = (ReplySwapPtr) SReplyIDispatch;
EventSwapVector[DeviceValuator] = SEventIDispatch;
EventSwapVector[DeviceKeyPress] = SEventIDispatch;
EventSwapVector[DeviceKeyRelease] = SEventIDispatch;
EventSwapVector[DeviceButtonPress] = SEventIDispatch;
EventSwapVector[DeviceButtonRelease] = SEventIDispatch;
EventSwapVector[DeviceMotionNotify] = SEventIDispatch;
EventSwapVector[DeviceFocusIn] = SEventIDispatch;
EventSwapVector[DeviceFocusOut] = SEventIDispatch;
EventSwapVector[ProximityIn] = SEventIDispatch;
EventSwapVector[ProximityOut] = SEventIDispatch;
EventSwapVector[DeviceStateNotify] = SEventIDispatch;
EventSwapVector[DeviceKeyStateNotify] = SEventIDispatch;
EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
} else {
FatalError("IExtensionInit: AddExtensions failed\n");
}
}
/*************************************************************************
*
* ProcIDispatch - main dispatch routine for requests to this extension.
@ -260,7 +215,7 @@ XInputExtensionInit(void)
*
*/
int
static int
ProcIDispatch(register ClientPtr client)
{
REQUEST(xReq);
@ -349,7 +304,7 @@ ProcIDispatch(register ClientPtr client)
*
*/
int
static int
SProcIDispatch(register ClientPtr client)
{
REQUEST(xReq);
@ -441,7 +396,7 @@ SProcIDispatch(register ClientPtr client)
if (rep->RepType == X_##code) \
SRepX##code (client, len, (x##code##Reply *) rep)
void
static void
SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
/* All we look at is the type field */
{ /* This is common to all replies */
@ -500,68 +455,13 @@ SReplyIDispatch(ClientPtr client, int len, xGrabDeviceReply * rep)
}
}
/*****************************************************************************
*
* SEventIDispatch
*
* Swap any events defined in this extension.
*/
#define DO_SWAP(func,type) func ((type *)from, (type *)to)
void
SEventIDispatch(xEvent * from, xEvent * to)
{
int type = from->u.u.type & 0177;
if (type == DeviceValuator)
DO_SWAP(SEventDeviceValuator, deviceValuator);
else if (type == DeviceKeyPress) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceKeyRelease) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceButtonPress) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceButtonRelease) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceMotionNotify) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceFocusIn)
DO_SWAP(SEventFocus, deviceFocus);
else if (type == DeviceFocusOut)
DO_SWAP(SEventFocus, deviceFocus);
else if (type == ProximityIn) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == ProximityOut) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceStateNotify)
DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
else if (type == DeviceKeyStateNotify)
DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
else if (type == DeviceButtonStateNotify)
DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
else if (type == DeviceMappingNotify)
DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
else if (type == ChangeDeviceNotify)
DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
else {
FatalError("XInputExtension: Impossible event!\n");
}
}
/************************************************************************
*
* This function swaps the DeviceValuator event.
*
*/
void
static void
SEventDeviceValuator(deviceValuator * from, deviceValuator * to)
{
register char n;
@ -577,7 +477,7 @@ SEventDeviceValuator(deviceValuator * from, deviceValuator * to)
}
}
void
static void
SEventFocus(deviceFocus * from, deviceFocus * to)
{
register char n;
@ -588,7 +488,7 @@ SEventFocus(deviceFocus * from, deviceFocus * to)
swapl(&to->window, n);
}
void
static void
SDeviceStateNotifyEvent(deviceStateNotify * from, deviceStateNotify * to)
{
register int i;
@ -604,7 +504,7 @@ SDeviceStateNotifyEvent(deviceStateNotify * from, deviceStateNotify * to)
}
}
void
static void
SDeviceKeyStateNotifyEvent(deviceKeyStateNotify * from,
deviceKeyStateNotify * to)
{
@ -614,7 +514,7 @@ SDeviceKeyStateNotifyEvent(deviceKeyStateNotify * from,
swaps(&to->sequenceNumber, n);
}
void
static void
SDeviceButtonStateNotifyEvent(deviceButtonStateNotify * from,
deviceButtonStateNotify * to)
{
@ -624,7 +524,7 @@ SDeviceButtonStateNotifyEvent(deviceButtonStateNotify * from,
swaps(&to->sequenceNumber, n);
}
void
static void
SChangeDeviceNotifyEvent(changeDeviceNotify * from, changeDeviceNotify * to)
{
register char n;
@ -634,7 +534,7 @@ SChangeDeviceNotifyEvent(changeDeviceNotify * from, changeDeviceNotify * to)
swapl(&to->time, n);
}
void
static void
SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
{
register char n;
@ -644,7 +544,7 @@ SDeviceMappingNotifyEvent(deviceMappingNotify * from, deviceMappingNotify * to)
swapl(&to->time, n);
}
void
static void
SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to)
{
register char n;
@ -655,13 +555,106 @@ SDevicePresenceNotifyEvent (devicePresenceNotify *from, devicePresenceNotify *to
swaps(&to->control, n);
}
/**************************************************************************
*
* Allow the specified event to have its propagation suppressed.
* The default is to not allow suppression of propagation.
*
*/
static void
AllowPropagateSuppress(Mask mask)
{
int i;
for (i = 0; i < MAX_DEVICES; i++)
PropagateMask[i] |= mask;
}
/**************************************************************************
*
* Return the next available extension event mask.
*
*/
static Mask
GetNextExtEventMask(void)
{
int i;
Mask mask = lastExtEventMask;
if (lastExtEventMask == 0) {
FatalError("GetNextExtEventMask: no more events are available.");
}
lastExtEventMask <<= 1;
for (i = 0; i < MAX_DEVICES; i++)
ExtValidMasks[i] |= mask;
return mask;
}
/**************************************************************************
*
* Record an event mask where there is no unique corresponding event type.
* We can't call SetMaskForEvent, since that would clobber the existing
* mask for that event. MotionHint and ButtonMotion are examples.
*
* Since extension event types will never be less than 64, we can use
* 0-63 in the EventInfo array as the "type" to be used to look up this
* mask. This means that the corresponding macros such as
* DevicePointerMotionHint must have access to the same constants.
*
*/
static void
SetEventInfo(Mask mask, int constant)
{
EventInfo[ExtEventIndex].mask = mask;
EventInfo[ExtEventIndex++].type = constant;
}
/**************************************************************************
*
* Allow the specified event to be restricted to being selected by one
* client at a time.
* The default is to allow more than one client to select the event.
*
*/
static void
SetExclusiveAccess(Mask mask)
{
int i;
for (i = 0; i < MAX_DEVICES; i++)
ExtExclusiveMasks[i] |= mask;
}
/**************************************************************************
*
* Assign the specified mask to the specified event.
*
*/
static void
SetMaskForExtEvent(Mask mask, int event)
{
EventInfo[ExtEventIndex].mask = mask;
EventInfo[ExtEventIndex++].type = event;
if ((event < LASTEvent) || (event >= 128))
FatalError("MaskForExtensionEvent: bogus event number");
SetMaskForEvent(mask, event);
}
/************************************************************************
*
* This function sets up extension event types and masks.
*
*/
void
static void
FixExtensionEvents(ExtensionEntry * extEntry)
{
Mask mask;
@ -767,7 +760,7 @@ FixExtensionEvents(ExtensionEntry * extEntry)
*
*/
void
static void
RestoreExtensionEvents(void)
{
int i;
@ -815,7 +808,7 @@ RestoreExtensionEvents(void)
*
*/
void
static void
IResetProc(ExtensionEntry * unused)
{
@ -859,7 +852,7 @@ AssignTypeAndName(DeviceIntPtr dev, Atom type, char *name)
*
*/
void
static void
MakeDeviceTypeAtoms(void)
{
int i;
@ -892,95 +885,102 @@ LookupDeviceIntRec(CARD8 id)
return NULL;
}
/**************************************************************************
/*****************************************************************************
*
* Allow the specified event to be restricted to being selected by one
* client at a time.
* The default is to allow more than one client to select the event.
* SEventIDispatch
*
* Swap any events defined in this extension.
*/
#define DO_SWAP(func,type) func ((type *)from, (type *)to)
void
SetExclusiveAccess(Mask mask)
static void
SEventIDispatch(xEvent * from, xEvent * to)
{
int i;
int type = from->u.u.type & 0177;
for (i = 0; i < MAX_DEVICES; i++)
ExtExclusiveMasks[i] |= mask;
}
/**************************************************************************
*
* Allow the specified event to have its propagation suppressed.
* The default is to not allow suppression of propagation.
*
*/
void
AllowPropagateSuppress(Mask mask)
{
int i;
for (i = 0; i < MAX_DEVICES; i++)
PropagateMask[i] |= mask;
}
/**************************************************************************
*
* Return the next available extension event mask.
*
*/
Mask
GetNextExtEventMask(void)
{
int i;
Mask mask = lastExtEventMask;
if (lastExtEventMask == 0) {
FatalError("GetNextExtEventMask: no more events are available.");
if (type == DeviceValuator)
DO_SWAP(SEventDeviceValuator, deviceValuator);
else if (type == DeviceKeyPress) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceKeyRelease) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceButtonPress) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceButtonRelease) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceMotionNotify) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceFocusIn)
DO_SWAP(SEventFocus, deviceFocus);
else if (type == DeviceFocusOut)
DO_SWAP(SEventFocus, deviceFocus);
else if (type == ProximityIn) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == ProximityOut) {
SKeyButtonPtrEvent(from, to);
to->u.keyButtonPointer.pad1 = from->u.keyButtonPointer.pad1;
} else if (type == DeviceStateNotify)
DO_SWAP(SDeviceStateNotifyEvent, deviceStateNotify);
else if (type == DeviceKeyStateNotify)
DO_SWAP(SDeviceKeyStateNotifyEvent, deviceKeyStateNotify);
else if (type == DeviceButtonStateNotify)
DO_SWAP(SDeviceButtonStateNotifyEvent, deviceButtonStateNotify);
else if (type == DeviceMappingNotify)
DO_SWAP(SDeviceMappingNotifyEvent, deviceMappingNotify);
else if (type == ChangeDeviceNotify)
DO_SWAP(SChangeDeviceNotifyEvent, changeDeviceNotify);
else {
FatalError("XInputExtension: Impossible event!\n");
}
lastExtEventMask <<= 1;
for (i = 0; i < MAX_DEVICES; i++)
ExtValidMasks[i] |= mask;
return mask;
}
/**************************************************************************
/**********************************************************************
*
* Assign the specified mask to the specified event.
* IExtensionInit - initialize the input extension.
*
* Called from InitExtensions in main() or from QueryExtension() if the
* extension is dynamically loaded.
*
* This extension has several events and errors.
*
*/
void
SetMaskForExtEvent(Mask mask, int event)
XInputExtensionInit(void)
{
ExtensionEntry *extEntry;
EventInfo[ExtEventIndex].mask = mask;
EventInfo[ExtEventIndex++].type = event;
if ((event < LASTEvent) || (event >= 128))
FatalError("MaskForExtensionEvent: bogus event number");
SetMaskForEvent(mask, event);
}
/**************************************************************************
*
* Record an event mask where there is no unique corresponding event type.
* We can't call SetMaskForEvent, since that would clobber the existing
* mask for that event. MotionHint and ButtonMotion are examples.
*
* Since extension event types will never be less than 64, we can use
* 0-63 in the EventInfo array as the "type" to be used to look up this
* mask. This means that the corresponding macros such as
* DevicePointerMotionHint must have access to the same constants.
*
*/
void
SetEventInfo(Mask mask, int constant)
{
EventInfo[ExtEventIndex].mask = mask;
EventInfo[ExtEventIndex++].type = constant;
extEntry = AddExtension(INAME, IEVENTS, IERRORS, ProcIDispatch,
SProcIDispatch, IResetProc, StandardMinorOpcode);
if (extEntry) {
IReqCode = extEntry->base;
AllExtensionVersions[IReqCode - 128] = thisversion;
MakeDeviceTypeAtoms();
RT_INPUTCLIENT = CreateNewResourceType((DeleteType) InputClientGone);
FixExtensionEvents(extEntry);
ReplySwapVector[IReqCode] = (ReplySwapPtr) SReplyIDispatch;
EventSwapVector[DeviceValuator] = SEventIDispatch;
EventSwapVector[DeviceKeyPress] = SEventIDispatch;
EventSwapVector[DeviceKeyRelease] = SEventIDispatch;
EventSwapVector[DeviceButtonPress] = SEventIDispatch;
EventSwapVector[DeviceButtonRelease] = SEventIDispatch;
EventSwapVector[DeviceMotionNotify] = SEventIDispatch;
EventSwapVector[DeviceFocusIn] = SEventIDispatch;
EventSwapVector[DeviceFocusOut] = SEventIDispatch;
EventSwapVector[ProximityIn] = SEventIDispatch;
EventSwapVector[ProximityOut] = SEventIDispatch;
EventSwapVector[DeviceStateNotify] = SEventIDispatch;
EventSwapVector[DeviceKeyStateNotify] = SEventIDispatch;
EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
} else {
FatalError("IExtensionInit: AddExtensions failed\n");
}
}

293
Xi/getdctl.c
View File

@ -86,6 +86,152 @@ SProcXGetDeviceControl(register ClientPtr client)
return (ProcXGetDeviceControl(client));
}
/***********************************************************************
*
* This procedure copies DeviceResolution data, swapping if necessary.
*
*/
static void
CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
int length)
{
register char n;
AxisInfoPtr a;
xDeviceResolutionState *r;
int i, *iptr;
r = (xDeviceResolutionState *) buf;
r->control = DEVICE_RESOLUTION;
r->length = length;
r->num_valuators = v->numAxes;
buf += sizeof(xDeviceResolutionState);
iptr = (int *)buf;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->resolution;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->min_resolution;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->max_resolution;
if (client->swapped) {
swaps(&r->control, n);
swaps(&r->length, n);
swapl(&r->num_valuators, n);
iptr = (int *)buf;
for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
swapl(iptr, n);
}
}
}
static 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);
}
}
static 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);
}
}
static 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);
}
}
static 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,
* if the client and server have a different byte ordering.
*
*/
void
SRepXGetDeviceControl(ClientPtr client, int size, xGetDeviceControlReply * rep)
{
register char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
WriteToClient(client, size, (char *)rep);
}
/***********************************************************************
*
* Get the state of the specified device control.
@ -186,150 +332,3 @@ ProcXGetDeviceControl(ClientPtr client)
xfree(savbuf);
return Success;
}
/***********************************************************************
*
* This procedure copies DeviceResolution data, swapping if necessary.
*
*/
void
CopySwapDeviceResolution(ClientPtr client, ValuatorClassPtr v, char *buf,
int length)
{
register char n;
AxisInfoPtr a;
xDeviceResolutionState *r;
int i, *iptr;
r = (xDeviceResolutionState *) buf;
r->control = DEVICE_RESOLUTION;
r->length = length;
r->num_valuators = v->numAxes;
buf += sizeof(xDeviceResolutionState);
iptr = (int *)buf;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->resolution;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->min_resolution;
for (i = 0, a = v->axes; i < v->numAxes; i++, a++)
*iptr++ = a->max_resolution;
if (client->swapped) {
swaps(&r->control, n);
swaps(&r->length, n);
swapl(&r->num_valuators, n);
iptr = (int *)buf;
for (i = 0; i < (3 * v->numAxes); i++, iptr++) {
swapl(iptr, n);
}
}
}
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,
* if the client and server have a different byte ordering.
*
*/
void
SRepXGetDeviceControl(ClientPtr client, int size, xGetDeviceControlReply * rep)
{
register char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
WriteToClient(client, size, (char *)rep);
}

24
Xi/getdctl.h
View File

@ -36,30 +36,6 @@ int SProcXGetDeviceControl(ClientPtr /* client */
int ProcXGetDeviceControl(ClientPtr /* client */
);
void CopySwapDeviceResolution(ClientPtr /* client */ ,
ValuatorClassPtr /* v */ ,
char * /* buf */ ,
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 */

400
Xi/getfctl.c
View File

@ -84,6 +84,206 @@ SProcXGetFeedbackControl(register ClientPtr client)
return (ProcXGetFeedbackControl(client));
}
/***********************************************************************
*
* This procedure copies KbdFeedbackClass data, swapping if necessary.
*
*/
static void
CopySwapKbdFeedback(ClientPtr client, KbdFeedbackPtr k, char **buf)
{
int i;
register char n;
xKbdFeedbackState *k2;
k2 = (xKbdFeedbackState *) * buf;
k2->class = KbdFeedbackClass;
k2->length = sizeof(xKbdFeedbackState);
k2->id = k->ctrl.id;
k2->click = k->ctrl.click;
k2->percent = k->ctrl.bell;
k2->pitch = k->ctrl.bell_pitch;
k2->duration = k->ctrl.bell_duration;
k2->led_mask = k->ctrl.leds;
k2->global_auto_repeat = k->ctrl.autoRepeat;
for (i = 0; i < 32; i++)
k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
if (client->swapped) {
swaps(&k2->length, n);
swaps(&k2->pitch, n);
swaps(&k2->duration, n);
swapl(&k2->led_mask, n);
swapl(&k2->led_values, n);
}
*buf += sizeof(xKbdFeedbackState);
}
/***********************************************************************
*
* This procedure copies PtrFeedbackClass data, swapping if necessary.
*
*/
static void
CopySwapPtrFeedback(ClientPtr client, PtrFeedbackPtr p, char **buf)
{
register char n;
xPtrFeedbackState *p2;
p2 = (xPtrFeedbackState *) * buf;
p2->class = PtrFeedbackClass;
p2->length = sizeof(xPtrFeedbackState);
p2->id = p->ctrl.id;
p2->accelNum = p->ctrl.num;
p2->accelDenom = p->ctrl.den;
p2->threshold = p->ctrl.threshold;
if (client->swapped) {
swaps(&p2->length, n);
swaps(&p2->accelNum, n);
swaps(&p2->accelDenom, n);
swaps(&p2->threshold, n);
}
*buf += sizeof(xPtrFeedbackState);
}
/***********************************************************************
*
* This procedure copies IntegerFeedbackClass data, swapping if necessary.
*
*/
static void
CopySwapIntegerFeedback(ClientPtr client, IntegerFeedbackPtr i, char **buf)
{
register char n;
xIntegerFeedbackState *i2;
i2 = (xIntegerFeedbackState *) * buf;
i2->class = IntegerFeedbackClass;
i2->length = sizeof(xIntegerFeedbackState);
i2->id = i->ctrl.id;
i2->resolution = i->ctrl.resolution;
i2->min_value = i->ctrl.min_value;
i2->max_value = i->ctrl.max_value;
if (client->swapped) {
swaps(&i2->length, n);
swapl(&i2->resolution, n);
swapl(&i2->min_value, n);
swapl(&i2->max_value, n);
}
*buf += sizeof(xIntegerFeedbackState);
}
/***********************************************************************
*
* This procedure copies StringFeedbackClass data, swapping if necessary.
*
*/
static void
CopySwapStringFeedback(ClientPtr client, StringFeedbackPtr s, char **buf)
{
int i;
register char n;
xStringFeedbackState *s2;
KeySym *kptr;
s2 = (xStringFeedbackState *) * buf;
s2->class = StringFeedbackClass;
s2->length = sizeof(xStringFeedbackState) +
s->ctrl.num_symbols_supported * sizeof(KeySym);
s2->id = s->ctrl.id;
s2->max_symbols = s->ctrl.max_symbols;
s2->num_syms_supported = s->ctrl.num_symbols_supported;
*buf += sizeof(xStringFeedbackState);
kptr = (KeySym *) (*buf);
for (i = 0; i < s->ctrl.num_symbols_supported; i++)
*kptr++ = *(s->ctrl.symbols_supported + i);
if (client->swapped) {
swaps(&s2->length, n);
swaps(&s2->max_symbols, n);
swaps(&s2->num_syms_supported, n);
kptr = (KeySym *) (*buf);
for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
swapl(kptr, n);
}
}
*buf += (s->ctrl.num_symbols_supported * sizeof(KeySym));
}
/***********************************************************************
*
* This procedure copies LedFeedbackClass data, swapping if necessary.
*
*/
static void
CopySwapLedFeedback(ClientPtr client, LedFeedbackPtr l, char **buf)
{
register char n;
xLedFeedbackState *l2;
l2 = (xLedFeedbackState *) * buf;
l2->class = LedFeedbackClass;
l2->length = sizeof(xLedFeedbackState);
l2->id = l->ctrl.id;
l2->led_values = l->ctrl.led_values;
l2->led_mask = l->ctrl.led_mask;
if (client->swapped) {
swaps(&l2->length, n);
swapl(&l2->led_values, n);
swapl(&l2->led_mask, n);
}
*buf += sizeof(xLedFeedbackState);
}
/***********************************************************************
*
* This procedure copies BellFeedbackClass data, swapping if necessary.
*
*/
static void
CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
{
register char n;
xBellFeedbackState *b2;
b2 = (xBellFeedbackState *) * buf;
b2->class = BellFeedbackClass;
b2->length = sizeof(xBellFeedbackState);
b2->id = b->ctrl.id;
b2->percent = b->ctrl.percent;
b2->pitch = b->ctrl.pitch;
b2->duration = b->ctrl.duration;
if (client->swapped) {
swaps(&b2->length, n);
swaps(&b2->pitch, n);
swaps(&b2->duration, n);
}
*buf += sizeof(xBellFeedbackState);
}
/***********************************************************************
*
* This procedure writes the reply for the xGetFeedbackControl function,
* if the client and server have a different byte ordering.
*
*/
void
SRepXGetFeedbackControl(ClientPtr client, int size,
xGetFeedbackControlReply * rep)
{
register char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
swaps(&rep->num_feedbacks, n);
WriteToClient(client, size, (char *)rep);
}
/***********************************************************************
*
* Get the feedback control state.
@ -176,203 +376,3 @@ ProcXGetFeedbackControl(ClientPtr client)
xfree(savbuf);
return Success;
}
/***********************************************************************
*
* This procedure copies KbdFeedbackClass data, swapping if necessary.
*
*/
void
CopySwapKbdFeedback(ClientPtr client, KbdFeedbackPtr k, char **buf)
{
int i;
register char n;
xKbdFeedbackState *k2;
k2 = (xKbdFeedbackState *) * buf;
k2->class = KbdFeedbackClass;
k2->length = sizeof(xKbdFeedbackState);
k2->id = k->ctrl.id;
k2->click = k->ctrl.click;
k2->percent = k->ctrl.bell;
k2->pitch = k->ctrl.bell_pitch;
k2->duration = k->ctrl.bell_duration;
k2->led_mask = k->ctrl.leds;
k2->global_auto_repeat = k->ctrl.autoRepeat;
for (i = 0; i < 32; i++)
k2->auto_repeats[i] = k->ctrl.autoRepeats[i];
if (client->swapped) {
swaps(&k2->length, n);
swaps(&k2->pitch, n);
swaps(&k2->duration, n);
swapl(&k2->led_mask, n);
swapl(&k2->led_values, n);
}
*buf += sizeof(xKbdFeedbackState);
}
/***********************************************************************
*
* This procedure copies PtrFeedbackClass data, swapping if necessary.
*
*/
void
CopySwapPtrFeedback(ClientPtr client, PtrFeedbackPtr p, char **buf)
{
register char n;
xPtrFeedbackState *p2;
p2 = (xPtrFeedbackState *) * buf;
p2->class = PtrFeedbackClass;
p2->length = sizeof(xPtrFeedbackState);
p2->id = p->ctrl.id;
p2->accelNum = p->ctrl.num;
p2->accelDenom = p->ctrl.den;
p2->threshold = p->ctrl.threshold;
if (client->swapped) {
swaps(&p2->length, n);
swaps(&p2->accelNum, n);
swaps(&p2->accelDenom, n);
swaps(&p2->threshold, n);
}
*buf += sizeof(xPtrFeedbackState);
}
/***********************************************************************
*
* This procedure copies IntegerFeedbackClass data, swapping if necessary.
*
*/
void
CopySwapIntegerFeedback(ClientPtr client, IntegerFeedbackPtr i, char **buf)
{
register char n;
xIntegerFeedbackState *i2;
i2 = (xIntegerFeedbackState *) * buf;
i2->class = IntegerFeedbackClass;
i2->length = sizeof(xIntegerFeedbackState);
i2->id = i->ctrl.id;
i2->resolution = i->ctrl.resolution;
i2->min_value = i->ctrl.min_value;
i2->max_value = i->ctrl.max_value;
if (client->swapped) {
swaps(&i2->length, n);
swapl(&i2->resolution, n);
swapl(&i2->min_value, n);
swapl(&i2->max_value, n);
}
*buf += sizeof(xIntegerFeedbackState);
}
/***********************************************************************
*
* This procedure copies StringFeedbackClass data, swapping if necessary.
*
*/
void
CopySwapStringFeedback(ClientPtr client, StringFeedbackPtr s, char **buf)
{
int i;
register char n;
xStringFeedbackState *s2;
KeySym *kptr;
s2 = (xStringFeedbackState *) * buf;
s2->class = StringFeedbackClass;
s2->length = sizeof(xStringFeedbackState) +
s->ctrl.num_symbols_supported * sizeof(KeySym);
s2->id = s->ctrl.id;
s2->max_symbols = s->ctrl.max_symbols;
s2->num_syms_supported = s->ctrl.num_symbols_supported;
*buf += sizeof(xStringFeedbackState);
kptr = (KeySym *) (*buf);
for (i = 0; i < s->ctrl.num_symbols_supported; i++)
*kptr++ = *(s->ctrl.symbols_supported + i);
if (client->swapped) {
swaps(&s2->length, n);
swaps(&s2->max_symbols, n);
swaps(&s2->num_syms_supported, n);
kptr = (KeySym *) (*buf);
for (i = 0; i < s->ctrl.num_symbols_supported; i++, kptr++) {
swapl(kptr, n);
}
}
*buf += (s->ctrl.num_symbols_supported * sizeof(KeySym));
}
/***********************************************************************
*
* This procedure copies LedFeedbackClass data, swapping if necessary.
*
*/
void
CopySwapLedFeedback(ClientPtr client, LedFeedbackPtr l, char **buf)
{
register char n;
xLedFeedbackState *l2;
l2 = (xLedFeedbackState *) * buf;
l2->class = LedFeedbackClass;
l2->length = sizeof(xLedFeedbackState);
l2->id = l->ctrl.id;
l2->led_values = l->ctrl.led_values;
l2->led_mask = l->ctrl.led_mask;
if (client->swapped) {
swaps(&l2->length, n);
swapl(&l2->led_values, n);
swapl(&l2->led_mask, n);
}
*buf += sizeof(xLedFeedbackState);
}
/***********************************************************************
*
* This procedure copies BellFeedbackClass data, swapping if necessary.
*
*/
void
CopySwapBellFeedback(ClientPtr client, BellFeedbackPtr b, char **buf)
{
register char n;
xBellFeedbackState *b2;
b2 = (xBellFeedbackState *) * buf;
b2->class = BellFeedbackClass;
b2->length = sizeof(xBellFeedbackState);
b2->id = b->ctrl.id;
b2->percent = b->ctrl.percent;
b2->pitch = b->ctrl.pitch;
b2->duration = b->ctrl.duration;
if (client->swapped) {
swaps(&b2->length, n);
swaps(&b2->pitch, n);
swaps(&b2->duration, n);
}
*buf += sizeof(xBellFeedbackState);
}
/***********************************************************************
*
* This procedure writes the reply for the xGetFeedbackControl function,
* if the client and server have a different byte ordering.
*
*/
void
SRepXGetFeedbackControl(ClientPtr client, int size,
xGetFeedbackControlReply * rep)
{
register char n;
swaps(&rep->sequenceNumber, n);
swapl(&rep->length, n);
swaps(&rep->num_feedbacks, n);
WriteToClient(client, size, (char *)rep);
}

30
Xi/getfctl.h
View File

@ -36,36 +36,6 @@ int SProcXGetFeedbackControl(ClientPtr /* client */
int ProcXGetFeedbackControl(ClientPtr /* client */
);
void CopySwapKbdFeedback(ClientPtr /* client */ ,
KbdFeedbackPtr /* k */ ,
char ** /* buf */
);
void CopySwapPtrFeedback(ClientPtr /* client */ ,
PtrFeedbackPtr /* p */ ,
char ** /* buf */
);
void CopySwapIntegerFeedback(ClientPtr /* client */ ,
IntegerFeedbackPtr /* i */ ,
char ** /* buf */
);
void CopySwapStringFeedback(ClientPtr /* client */ ,
StringFeedbackPtr /* s */ ,
char ** /* buf */
);
void CopySwapLedFeedback(ClientPtr /* client */ ,
LedFeedbackPtr /* l */ ,
char ** /* buf */
);
void CopySwapBellFeedback(ClientPtr /* client */ ,
BellFeedbackPtr /* b */ ,
char ** /* buf */
);
void SRepXGetFeedbackControl(ClientPtr /* client */ ,
int /* size */ ,
xGetFeedbackControlReply * /* rep */

424
Xi/listdev.c
View File

@ -86,6 +86,218 @@ SProcXListInputDevices(register ClientPtr client)
return (ProcXListInputDevices(client));
}
/***********************************************************************
*
* This procedure calculates the size of the information to be returned
* for an input device.
*
*/
static void
SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
{
int chunks;
*namesize += 1;
if (d->name)
*namesize += strlen(d->name);
if (d->key != NULL)
*size += sizeof(xKeyInfo);
if (d->button != NULL)
*size += sizeof(xButtonInfo);
if (d->valuator != NULL) {
chunks = ((int)d->valuator->numAxes + 19) / VPC;
*size += (chunks * sizeof(xValuatorInfo) +
d->valuator->numAxes * sizeof(xAxisInfo));
}
}
/***********************************************************************
*
* This procedure copies data to the DeviceInfo struct, swapping if necessary.
*
* We need the extra byte in the allocated buffer, because the trailing null
* hammers one extra byte, which is overwritten by the next name except for
* the last name copied.
*
*/
static void
CopyDeviceName(char **namebuf, char *name)
{
char *nameptr = (char *)*namebuf;
if (name) {
*nameptr++ = strlen(name);
strcpy(nameptr, name);
*namebuf += (strlen(name) + 1);
} else {
*nameptr++ = 0;
*namebuf += 1;
}
}
/***********************************************************************
*
* This procedure copies ButtonClass information, swapping if necessary.
*
*/
static void
CopySwapButtonClass(register ClientPtr client, ButtonClassPtr b, char **buf)
{
register char n;
xButtonInfoPtr b2;
b2 = (xButtonInfoPtr) * buf;
b2->class = ButtonClass;
b2->length = sizeof(xButtonInfo);
b2->num_buttons = b->numButtons;
if (client->swapped) {
swaps(&b2->num_buttons, n); /* macro - braces are required */
}
*buf += sizeof(xButtonInfo);
}
/***********************************************************************
*
* This procedure copies data to the DeviceInfo struct, swapping if necessary.
*
*/
static void
CopySwapDevice(register ClientPtr client, DeviceIntPtr d, int num_classes,
char **buf)
{
register char n;
xDeviceInfoPtr dev;
dev = (xDeviceInfoPtr) * buf;
dev->id = d->id;
dev->type = d->type;
dev->num_classes = num_classes;
if (d == inputInfo.keyboard)
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) {
swapl(&dev->type, n); /* macro - braces are required */
}
*buf += sizeof(xDeviceInfo);
}
/***********************************************************************
*
* This procedure copies KeyClass information, swapping if necessary.
*
*/
static void
CopySwapKeyClass(register ClientPtr client, KeyClassPtr k, char **buf)
{
register char n;
xKeyInfoPtr k2;
k2 = (xKeyInfoPtr) * buf;
k2->class = KeyClass;
k2->length = sizeof(xKeyInfo);
k2->min_keycode = k->curKeySyms.minKeyCode;
k2->max_keycode = k->curKeySyms.maxKeyCode;
k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
if (client->swapped) {
swaps(&k2->num_keys, n);
}
*buf += sizeof(xKeyInfo);
}
/***********************************************************************
*
* This procedure copies ValuatorClass information, swapping if necessary.
*
* Devices may have up to 255 valuators. The length of a ValuatorClass is
* defined to be sizeof(ValuatorClassInfo) + num_axes * sizeof (xAxisInfo).
* The maximum length is therefore (8 + 255 * 12) = 3068. However, the
* length field is one byte. If a device has more than 20 valuators, we
* must therefore return multiple valuator classes to the client.
*
*/
static int
CopySwapValuatorClass(register ClientPtr client, ValuatorClassPtr v, char **buf)
{
int i, j, axes, t_axes;
register char n;
xValuatorInfoPtr v2;
AxisInfo *a;
xAxisInfoPtr a2;
for (i = 0, axes = v->numAxes; i < ((v->numAxes + 19) / VPC);
i++, axes -= VPC) {
t_axes = axes < VPC ? axes : VPC;
if (t_axes < 0)
t_axes = v->numAxes % VPC;
v2 = (xValuatorInfoPtr) * buf;
v2->class = ValuatorClass;
v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo);
v2->num_axes = t_axes;
v2->mode = v->mode & DeviceMode;
v2->motion_buffer_size = v->numMotionEvents;
if (client->swapped) {
swapl(&v2->motion_buffer_size, n);
}
*buf += sizeof(xValuatorInfo);
a = v->axes + (VPC * i);
a2 = (xAxisInfoPtr) * buf;
for (j = 0; j < t_axes; j++) {
a2->min_value = a->min_value;
a2->max_value = a->max_value;
a2->resolution = a->resolution;
if (client->swapped) {
swapl(&a2->min_value, n);
swapl(&a2->max_value, n);
swapl(&a2->resolution, n);
}
a2++;
a++;
*buf += sizeof(xAxisInfo);
}
}
return (i);
}
/***********************************************************************
*
* This procedure lists information to be returned for an input device.
*
*/
static void
ListDeviceInfo(ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev,
char **devbuf, char **classbuf, char **namebuf)
{
CopyDeviceName(namebuf, d->name);
CopySwapDevice(client, d, 0, devbuf);
if (d->key != NULL) {
CopySwapKeyClass(client, d->key, classbuf);
dev->num_classes++;
}
if (d->button != NULL) {
CopySwapButtonClass(client, d->button, classbuf);
dev->num_classes++;
}
if (d->valuator != NULL) {
dev->num_classes +=
CopySwapValuatorClass(client, d->valuator, classbuf);
}
}
/***********************************************************************
*
* This procedure lists the input devices available to the server.
@ -145,218 +357,6 @@ ProcXListInputDevices(register ClientPtr client)
return Success;
}
/***********************************************************************
*
* This procedure calculates the size of the information to be returned
* for an input device.
*
*/
void
SizeDeviceInfo(DeviceIntPtr d, int *namesize, int *size)
{
int chunks;
*namesize += 1;
if (d->name)
*namesize += strlen(d->name);
if (d->key != NULL)
*size += sizeof(xKeyInfo);
if (d->button != NULL)
*size += sizeof(xButtonInfo);
if (d->valuator != NULL) {
chunks = ((int)d->valuator->numAxes + 19) / VPC;
*size += (chunks * sizeof(xValuatorInfo) +
d->valuator->numAxes * sizeof(xAxisInfo));
}
}
/***********************************************************************
*
* This procedure lists information to be returned for an input device.
*
*/
void
ListDeviceInfo(ClientPtr client, DeviceIntPtr d, xDeviceInfoPtr dev,
char **devbuf, char **classbuf, char **namebuf)
{
CopyDeviceName(namebuf, d->name);
CopySwapDevice(client, d, 0, devbuf);
if (d->key != NULL) {
CopySwapKeyClass(client, d->key, classbuf);
dev->num_classes++;
}
if (d->button != NULL) {
CopySwapButtonClass(client, d->button, classbuf);
dev->num_classes++;
}
if (d->valuator != NULL) {
dev->num_classes +=
CopySwapValuatorClass(client, d->valuator, classbuf);
}
}
/***********************************************************************
*
* This procedure copies data to the DeviceInfo struct, swapping if necessary.
*
* We need the extra byte in the allocated buffer, because the trailing null
* hammers one extra byte, which is overwritten by the next name except for
* the last name copied.
*
*/
void
CopyDeviceName(char **namebuf, char *name)
{
char *nameptr = (char *)*namebuf;
if (name) {
*nameptr++ = strlen(name);
strcpy(nameptr, name);
*namebuf += (strlen(name) + 1);
} else {
*nameptr++ = 0;
*namebuf += 1;
}
}
/***********************************************************************
*
* This procedure copies data to the DeviceInfo struct, swapping if necessary.
*
*/
void
CopySwapDevice(register ClientPtr client, DeviceIntPtr d, int num_classes,
char **buf)
{
register char n;
xDeviceInfoPtr dev;
dev = (xDeviceInfoPtr) * buf;
dev->id = d->id;
dev->type = d->type;
dev->num_classes = num_classes;
if (d == inputInfo.keyboard)
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) {
swapl(&dev->type, n); /* macro - braces are required */
}
*buf += sizeof(xDeviceInfo);
}
/***********************************************************************
*
* This procedure copies KeyClass information, swapping if necessary.
*
*/
void
CopySwapKeyClass(register ClientPtr client, KeyClassPtr k, char **buf)
{
register char n;
xKeyInfoPtr k2;
k2 = (xKeyInfoPtr) * buf;
k2->class = KeyClass;
k2->length = sizeof(xKeyInfo);
k2->min_keycode = k->curKeySyms.minKeyCode;
k2->max_keycode = k->curKeySyms.maxKeyCode;
k2->num_keys = k2->max_keycode - k2->min_keycode + 1;
if (client->swapped) {
swaps(&k2->num_keys, n);
}
*buf += sizeof(xKeyInfo);
}
/***********************************************************************
*
* This procedure copies ButtonClass information, swapping if necessary.
*
*/
void
CopySwapButtonClass(register ClientPtr client, ButtonClassPtr b, char **buf)
{
register char n;
xButtonInfoPtr b2;
b2 = (xButtonInfoPtr) * buf;
b2->class = ButtonClass;
b2->length = sizeof(xButtonInfo);
b2->num_buttons = b->numButtons;
if (client->swapped) {
swaps(&b2->num_buttons, n); /* macro - braces are required */
}
*buf += sizeof(xButtonInfo);
}
/***********************************************************************
*
* This procedure copies ValuatorClass information, swapping if necessary.
*
* Devices may have up to 255 valuators. The length of a ValuatorClass is
* defined to be sizeof(ValuatorClassInfo) + num_axes * sizeof (xAxisInfo).
* The maximum length is therefore (8 + 255 * 12) = 3068. However, the
* length field is one byte. If a device has more than 20 valuators, we
* must therefore return multiple valuator classes to the client.
*
*/
int
CopySwapValuatorClass(register ClientPtr client, ValuatorClassPtr v, char **buf)
{
int i, j, axes, t_axes;
register char n;
xValuatorInfoPtr v2;
AxisInfo *a;
xAxisInfoPtr a2;
for (i = 0, axes = v->numAxes; i < ((v->numAxes + 19) / VPC);
i++, axes -= VPC) {
t_axes = axes < VPC ? axes : VPC;
if (t_axes < 0)
t_axes = v->numAxes % VPC;
v2 = (xValuatorInfoPtr) * buf;
v2->class = ValuatorClass;
v2->length = sizeof(xValuatorInfo) + t_axes * sizeof(xAxisInfo);
v2->num_axes = t_axes;
v2->mode = v->mode & DeviceMode;
v2->motion_buffer_size = v->numMotionEvents;
if (client->swapped) {
swapl(&v2->motion_buffer_size, n);
}
*buf += sizeof(xValuatorInfo);
a = v->axes + (VPC * i);
a2 = (xAxisInfoPtr) * buf;
for (j = 0; j < t_axes; j++) {
a2->min_value = a->min_value;
a2->max_value = a->max_value;
a2->resolution = a->resolution;
if (client->swapped) {
swapl(&a2->min_value, n);
swapl(&a2->max_value, n);
swapl(&a2->resolution, n);
}
a2++;
a++;
*buf += sizeof(xAxisInfo);
}
}
return (i);
}
/***********************************************************************
*
* This procedure writes the reply for the XListInputDevices function,

38
Xi/listdev.h
View File

@ -36,44 +36,6 @@ int SProcXListInputDevices(ClientPtr /* client */
int ProcXListInputDevices(ClientPtr /* client */
);
void SizeDeviceInfo(DeviceIntPtr /* d */ ,
int * /* namesize */ ,
int * /* size */
);
void ListDeviceInfo(ClientPtr /* client */ ,
DeviceIntPtr /* d */ ,
xDeviceInfoPtr /* dev */ ,
char ** /* devbuf */ ,
char ** /* classbuf */ ,
char ** /* namebuf */
);
void CopyDeviceName(char ** /* namebuf */ ,
char * /* name */
);
void CopySwapDevice(ClientPtr /* client */ ,
DeviceIntPtr /* d */ ,
int /* num_classes */ ,
char ** /* buf */
);
void CopySwapKeyClass(ClientPtr /* client */ ,
KeyClassPtr /* k */ ,
char ** /* buf */
);
void CopySwapButtonClass(ClientPtr /* client */ ,
ButtonClassPtr /* b */ ,
char ** /* buf */
);
int CopySwapValuatorClass(ClientPtr /* client */ ,
ValuatorClassPtr /* v */ ,
char ** /* buf */
);
void SRepXListInputDevices(ClientPtr /* client */ ,
int /* size */ ,
xListInputDevicesReply * /* rep */

124
afb/afb.h
View File

@ -78,27 +78,6 @@ extern void afbDoBitblt(
unsigned long /*planemask*/
);
extern RegionPtr afbBitBlt(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
GCPtr /*pGC*/,
int /*srcx*/,
int /*srcy*/,
int /*width*/,
int /*height*/,
int /*dstx*/,
int /*dsty*/,
void (*doBitBlt)(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
),
unsigned long /*planemask*/
);
extern RegionPtr afbCopyArea(
DrawablePtr /*pSrcDrawable*/,
DrawablePtr /*pDstDrawable*/,
@ -111,27 +90,6 @@ extern RegionPtr afbCopyArea(
int /*dsty*/
);
extern RegionPtr afbCopyPlane(
DrawablePtr /*pSrcDrawable*/,
DrawablePtr /*pDstDrawable*/,
GCPtr/*pGC*/,
int /*srcx*/,
int /*srcy*/,
int /*width*/,
int /*height*/,
int /*dstx*/,
int /*dsty*/,
unsigned long /*plane*/
);
extern void afbCopy1ToN(
DrawablePtr /*pSrc*/,
DrawablePtr /*pDst*/,
int /*alu*/,
RegionPtr /*prgnDst*/,
DDXPointPtr /*pptSrc*/,
unsigned long /*planemask*/
);
/* afbbltC.c */
extern void afbDoBitbltCopy(
@ -273,23 +231,6 @@ extern Bool afbInitializeColormap(
ColormapPtr /*pmap*/
);
extern int afbExpandDirectColors(
ColormapPtr /*pmap*/,
int /*ndefs*/,
xColorItem * /*indefs*/,
xColorItem * /*outdefs*/
);
extern Bool afbCreateDefColormap(
ScreenPtr /*pScreen*/
);
extern Bool afbSetVisualTypes(
int /*depth*/,
int /*visuals*/,
int /*bitsPerRGB*/
);
extern Bool afbInitVisuals(
VisualPtr * /*visualp*/,
DepthPtr * /*depthp*/,
@ -410,16 +351,6 @@ extern Bool afbCreateGC(
GCPtr /*pGC*/
);
extern void afbValidateGC(
GCPtr /*pGC*/,
unsigned long /*changes*/,
DrawablePtr /*pDrawable*/
);
extern void afbDestroyGC(
GCPtr /*pGC*/
);
extern void afbReduceRop(
int /*alu*/,
Pixel /*src*/,
@ -428,19 +359,6 @@ extern void afbReduceRop(
unsigned char * /*rrops*/
);
extern void afbReduceOpaqueStipple (
Pixel /*fg*/,
Pixel /*bg*/,
unsigned long /*planemask*/,
int /*depth*/,
unsigned char * /*rrops*/
);
extern void afbComputeCompositeClip(
GCPtr /*pGC*/,
DrawablePtr /*pDrawable*/
);
/* afbgetsp.c */
extern void afbGetSpans(
@ -588,14 +506,6 @@ extern Bool afbDestroyPixmap(
PixmapPtr /*pPixmap*/
);
extern PixmapPtr afbCopyPixmap(
PixmapPtr /*pSrc*/
);
extern void afbPadPixmap(
PixmapPtr /*pPixmap*/
);
extern void afbXRotatePixmap(
PixmapPtr /*pPix*/,
int /*rw*/
@ -637,20 +547,9 @@ extern void afbPushPixels(
int /*xOrg*/,
int /*yOrg*/
);
/* afbscrclse.c */
extern Bool afbCloseScreen(
int /*index*/,
ScreenPtr /*pScreen*/
);
/* afbscrinit.c */
extern Bool afbAllocatePrivates(
ScreenPtr /*pScreen*/,
int * /*pWinIndex*/,
int * /*pGCIndex*/
);
extern Bool afbScreenInit(
ScreenPtr /*pScreen*/,
pointer /*pbits*/,
@ -661,15 +560,6 @@ extern Bool afbScreenInit(
int /*width*/
);
extern PixmapPtr afbGetWindowPixmap(
WindowPtr /*pWin*/
);
extern void afbSetWindowPixmap(
WindowPtr /*pWin*/,
PixmapPtr /*pPix*/
);
/* afbseg.c */
extern void afbSegmentSS(
@ -687,20 +577,6 @@ extern void afbSegmentSD(
);
/* afbsetsp.c */
extern void afbSetScanline(
int /*y*/,
int /*xOrigin*/,
int /*xStart*/,
int /*xEnd*/,
PixelType * /*psrc*/,
int /*alu*/,
PixelType * /*pdstBase*/,
int /*widthDst*/,
int /*sizeDst*/,
int /*depthDst*/,
int /*sizeSrc*/
);
extern void afbSetSpans(
DrawablePtr /*pDrawable*/,
GCPtr /*pGC*/,

148
afb/afbbitblt.c
View File

@ -67,9 +67,6 @@ SOFTWARE.
#include "afb.h"
#include "maskbits.h"
static unsigned char afbRropsOS[AFB_MAX_DEPTH];
/* CopyArea and CopyPlane for a monchrome frame buffer
@ -126,34 +123,7 @@ afbDoBitblt(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst, DDXP
typedef void (*afb_blit_func)
(DrawablePtr, DrawablePtr, int, RegionPtr, DDXPointPtr, unsigned long);
RegionPtr
afbCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty)
{
afb_blit_func doBitBlt;
switch (pGC->alu) {
case GXcopy:
doBitBlt = afbDoBitbltCopy;
break;
case GXxor:
doBitBlt = afbDoBitbltXor;
break;
case GXcopyInverted:
doBitBlt = afbDoBitbltCopyInverted;
break;
case GXor:
doBitBlt = afbDoBitbltOr;
break;
default:
doBitBlt = afbDoBitbltGeneral;
break;
}
return(afbBitBlt(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
width, height, dstx, dsty, doBitBlt, pGC->planemask));
}
RegionPtr
static RegionPtr
afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable, register GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty, afb_blit_func doBitBlt, long unsigned int planemask)
{
RegionPtr prgnSrcClip = NULL; /* may be a new region, or just a copy */
@ -346,102 +316,28 @@ afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable,
}
RegionPtr
afbCopyPlane(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, register GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty, long unsigned int plane)
afbCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GC *pGC, int srcx, int srcy, int width, int height, int dstx, int dsty)
{
int alu;
RegionPtr prgnExposed = NULL;
unsigned long old_planemask;
afb_blit_func doBitBlt;
if (pDstDrawable->depth == 1) {
old_planemask = pGC->planemask;
pGC->planemask = plane;
if ((pGC->fgPixel & 1) == 1 && (pGC->bgPixel & 1) == 0) {
prgnExposed = (*pGC->ops->CopyArea)(pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height, dstx, dsty);
} else if ((pGC->fgPixel & 1) == (pGC->bgPixel & 1)) {
unsigned char rop;
afbReduceRop(pGC->alu, pGC->fgPixel, 1, 1, &rop);
alu = pGC->alu;
pGC->alu = rop;
prgnExposed = (*pGC->ops->CopyArea)(pSrcDrawable, pDstDrawable, pGC,
srcx, srcy, width, height, dstx,
dsty);
pGC->alu = alu;
} else { /* need to invert the src */
alu = pGC->alu;
pGC->alu = afbInverseAlu[alu];
prgnExposed = (*pGC->ops->CopyArea)(pSrcDrawable, pDstDrawable, pGC,
srcx, srcy, width, height, dstx,
dsty);
pGC->alu = alu;
}
pGC->planemask = old_planemask;
} else {
int free_pixmap = FALSE;
PixmapPtr pBitmap = (PixmapPtr)pSrcDrawable;
ScreenPtr pScreen = pSrcDrawable->pScreen;
GCPtr pGC1 = NULL;
if (pSrcDrawable == pDstDrawable ||
pSrcDrawable->type == DRAWABLE_WINDOW || pSrcDrawable->depth != 1) {
/* Copy a plane from source drawable to a tmp 1-bit deep pixmap */
/* XXX: Range check width and height */
pBitmap = (*pScreen->CreatePixmap)(pScreen, width, height, 1);
if (!pBitmap)
return(NULL);
pGC1 = GetScratchGC(1, pScreen);
if (!pGC1) {
(*pScreen->DestroyPixmap)(pBitmap);
return(NULL);
}
ValidateGC((DrawablePtr)pBitmap, pGC1);
(void)afbBitBlt(pSrcDrawable, (DrawablePtr)pBitmap, pGC1, srcx, srcy,
width, height, 0, 0, afbDoBitbltCopy, plane);
free_pixmap = TRUE;
}
#if 0
else {
/* XXX: could cope with N-deep pixmap source case without using tmp
* src bitmap by setting up a scratch pixmap header and fiddle
* around with the pbits pointer.
*/
}
#endif
afbReduceOpaqueStipple(pGC->fgPixel, pGC->bgPixel, pGC->planemask,
pGC->depth, afbRropsOS);
(void)afbBitBlt((DrawablePtr)pBitmap, pDstDrawable, pGC, 0, 0, width,
height, dstx, dsty, afbCopy1ToN, pGC->planemask);
if (free_pixmap) {
(*pScreen->DestroyPixmap)(pBitmap);
FreeScratchGC(pGC1);
}
if (pGC->fExpose)
prgnExposed = miHandleExposures(pSrcDrawable, pDstDrawable, pGC, srcx,
srcy, width, height, dstx, dsty,
plane);
}
return prgnExposed;
}
void
afbCopy1ToN(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst, DDXPointPtr pptSrc, long unsigned int planemask)
{
int numRects = REGION_NUM_RECTS(prgnDst);
BoxPtr pbox = REGION_RECTS(prgnDst);
int r;
for (r = 0; r < numRects; r++, pbox++, pptSrc++) {
int dx = pptSrc->x;
int dy = pptSrc->y;
if (alu == GXcopy)
afbOpaqueStippleAreaCopy(pDst, 1, pbox, alu, (PixmapPtr)pSrc, dx, dy,
afbRropsOS, planemask);
else
afbOpaqueStippleAreaGeneral(pDst, 1, pbox, alu, (PixmapPtr)pSrc, dx,
dy, afbRropsOS, planemask);
switch (pGC->alu) {
case GXcopy:
doBitBlt = afbDoBitbltCopy;
break;
case GXxor:
doBitBlt = afbDoBitbltXor;
break;
case GXcopyInverted:
doBitBlt = afbDoBitbltCopyInverted;
break;
case GXor:
doBitBlt = afbDoBitbltOr;
break;
default:
doBitBlt = afbDoBitbltGeneral;
break;
}
return(afbBitBlt(pSrcDrawable, pDstDrawable, pGC, srcx, srcy,
width, height, dstx, dsty, doBitBlt, pGC->planemask));
}

18
afb/afbcmap.c
View File

@ -70,24 +70,6 @@ afbInitializeColormap(register ColormapPtr pmap)
return miInitializeColormap(pmap);
}
int
afbExpandDirectColors(ColormapPtr pmap, int ndef, xColorItem *indefs, xColorItem *outdefs)
{
return miExpandDirectColors(pmap, ndef, indefs, outdefs);
}
Bool
afbCreateDefColormap(ScreenPtr pScreen)
{
return miCreateDefColormap(pScreen);
}
Bool
afbSetVisualTypes(int depth, int visuals, int bitsPerRGB)
{
return miSetVisualTypes(depth, visuals, bitsPerRGB, -1);
}
/*
* Given a list of formats for a screen, create a list
* of visuals and depths for the screen which correspond to

266
afb/afbgc.c
View File

@ -69,6 +69,9 @@ SOFTWARE.
#include "maskbits.h"
static void afbDestroyGC(GCPtr);
static void afbValidateGC(GCPtr, unsigned long, DrawablePtr);
static GCFuncs afbFuncs = {
afbValidateGC,
miChangeGC,
@ -102,6 +105,33 @@ static GCOps afbGCOps = {
afbPushPixels
};
static void
afbReduceOpaqueStipple(PixelType fg, PixelType bg, unsigned long planemask,
int depth, unsigned char *rop)
{
register int d;
register Pixel mask = 1;
bg ^= fg;
for (d = 0; d < depth; d++, mask <<= 1) {
if (!(planemask & mask))
rop[d] = RROP_NOP;
else if (!(bg & mask)) {
/* Both fg and bg have a 0 or 1 in this plane */
if (fg & mask)
rop[d] = RROP_WHITE;
else
rop[d] = RROP_BLACK;
} else {
/* Both fg and bg have different bits on this plane */
if (fg & mask)
rop[d] = RROP_COPY;
else
rop[d] = RROP_INVERT;
}
}
}
Bool
afbCreateGC(pGC)
@ -136,6 +166,95 @@ afbCreateGC(pGC)
return TRUE;
}
static void
afbComputeCompositeClip(GCPtr pGC, DrawablePtr pDrawable)
{
if (pDrawable->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr) pDrawable;
RegionPtr pregWin;
Bool freeTmpClip, freeCompClip;
if (pGC->subWindowMode == IncludeInferiors) {
pregWin = NotClippedByChildren(pWin);
freeTmpClip = TRUE;
} else {
pregWin = &pWin->clipList;
freeTmpClip = FALSE;
}
freeCompClip = pGC->freeCompClip;
/*
* if there is no client clip, we can get by with just keeping the
* pointer we got, and remembering whether or not should destroy (or
* maybe re-use) it later. this way, we avoid unnecessary copying of
* regions. (this wins especially if many clients clip by children
* and have no client clip.)
*/
if (pGC->clientClipType == CT_NONE) {
if (freeCompClip)
REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
pGC->pCompositeClip = pregWin;
pGC->freeCompClip = freeTmpClip;
} else {
/*
* we need one 'real' region to put into the composite clip. if
* pregWin the current composite clip are real, we can get rid of
* one. if pregWin is real and the current composite clip isn't,
* use pregWin for the composite clip. if the current composite
* clip is real and pregWin isn't, use the current composite
* clip. if neither is real, create a new region.
*/
REGION_TRANSLATE(pGC->pScreen, pGC->clientClip,
pDrawable->x + pGC->clipOrg.x,
pDrawable->y + pGC->clipOrg.y);
if (freeCompClip) {
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip, pregWin,
pGC->clientClip);
if (freeTmpClip)
REGION_DESTROY(pGC->pScreen, pregWin);
} else if (freeTmpClip) {
REGION_INTERSECT(pGC->pScreen, pregWin, pregWin, pGC->clientClip);
pGC->pCompositeClip = pregWin;
} else {
pGC->pCompositeClip = REGION_CREATE(pGC->pScreen, NullBox, 0);
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
pregWin, pGC->clientClip);
}
pGC->freeCompClip = TRUE;
REGION_TRANSLATE(pGC->pScreen, pGC->clientClip,
-(pDrawable->x + pGC->clipOrg.x),
-(pDrawable->y + pGC->clipOrg.y));
}
} /* end of composite clip for a window */
else {
BoxRec pixbounds;
/* XXX should we translate by drawable.x/y here ? */
pixbounds.x1 = 0;
pixbounds.y1 = 0;
pixbounds.x2 = pDrawable->width;
pixbounds.y2 = pDrawable->height;
if (pGC->freeCompClip) {
REGION_RESET(pGC->pScreen, pGC->pCompositeClip, &pixbounds);
} else {
pGC->freeCompClip = TRUE;
pGC->pCompositeClip = REGION_CREATE(pGC->pScreen, &pixbounds, 1);
}
if (pGC->clientClipType == CT_REGION) {
REGION_TRANSLATE(pGC->pScreen, pGC->pCompositeClip, -pGC->clipOrg.x,
-pGC->clipOrg.y);
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
pGC->pCompositeClip, pGC->clientClip);
REGION_TRANSLATE(pGC->pScreen, pGC->pCompositeClip, pGC->clipOrg.x,
pGC->clipOrg.y);
}
} /* end of composite clip for pixmap */
} /* end afbComputeCompositeClip */
/* Clipping conventions
if the drawable is a window
CT_REGION ==> pCompositeClip really is the composite
@ -147,7 +266,7 @@ afbCreateGC(pGC)
*/
/*ARGSUSED*/
void
static void
afbValidateGC(pGC, changes, pDrawable)
register GCPtr pGC;
unsigned long changes;
@ -434,7 +553,7 @@ afbValidateGC(pGC, changes, pDrawable)
} /* end of new_fill */
}
void
static void
afbDestroyGC(pGC)
GCPtr pGC;
{
@ -445,58 +564,6 @@ afbDestroyGC(pGC)
miDestroyGCOps(pGC->ops);
}
/* table to map alu(src, dst) to alu(~src, dst) */
int afbInverseAlu[16] = {
GXclear,
GXandInverted,
GXnor,
GXcopyInverted,
GXand,
GXnoop,
GXequiv,
GXorInverted,
GXandReverse,
GXxor,
GXinvert,
GXnand,
GXcopy,
GXor,
GXorReverse,
GXset
};
void
afbReduceOpaqueStipple(fg, bg, planemask, depth, rop)
register PixelType fg;
register PixelType bg;
register unsigned long planemask;
int depth;
register unsigned char *rop;
{
register int d;
register Pixel mask = 1;
bg ^= fg;
for (d = 0; d < depth; d++, mask <<= 1) {
if (!(planemask & mask))
rop[d] = RROP_NOP;
else if (!(bg & mask)) {
/* Both fg and bg have a 0 or 1 in this plane */
if (fg & mask)
rop[d] = RROP_WHITE;
else
rop[d] = RROP_BLACK;
} else {
/* Both fg and bg have different bits on this plane */
if (fg & mask)
rop[d] = RROP_COPY;
else
rop[d] = RROP_INVERT;
}
}
}
void
afbReduceRop(alu, src, planemask, depth, rop)
register int alu;
@ -615,94 +682,3 @@ afbReduceRop(alu, src, planemask, depth, rop)
}
}
}
void
afbComputeCompositeClip(pGC, pDrawable)
GCPtr pGC;
DrawablePtr pDrawable;
{
if (pDrawable->type == DRAWABLE_WINDOW) {
WindowPtr pWin = (WindowPtr) pDrawable;
RegionPtr pregWin;
Bool freeTmpClip, freeCompClip;
if (pGC->subWindowMode == IncludeInferiors) {
pregWin = NotClippedByChildren(pWin);
freeTmpClip = TRUE;
} else {
pregWin = &pWin->clipList;
freeTmpClip = FALSE;
}
freeCompClip = pGC->freeCompClip;
/*
* if there is no client clip, we can get by with just keeping the
* pointer we got, and remembering whether or not should destroy (or
* maybe re-use) it later. this way, we avoid unnecessary copying of
* regions. (this wins especially if many clients clip by children
* and have no client clip.)
*/
if (pGC->clientClipType == CT_NONE) {
if (freeCompClip)
REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
pGC->pCompositeClip = pregWin;
pGC->freeCompClip = freeTmpClip;
} else {
/*
* we need one 'real' region to put into the composite clip. if
* pregWin the current composite clip are real, we can get rid of
* one. if pregWin is real and the current composite clip isn't,
* use pregWin for the composite clip. if the current composite
* clip is real and pregWin isn't, use the current composite
* clip. if neither is real, create a new region.
*/
REGION_TRANSLATE(pGC->pScreen, pGC->clientClip,
pDrawable->x + pGC->clipOrg.x,
pDrawable->y + pGC->clipOrg.y);
if (freeCompClip) {
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip, pregWin,
pGC->clientClip);
if (freeTmpClip)
REGION_DESTROY(pGC->pScreen, pregWin);
} else if (freeTmpClip) {
REGION_INTERSECT(pGC->pScreen, pregWin, pregWin, pGC->clientClip);
pGC->pCompositeClip = pregWin;
} else {
pGC->pCompositeClip = REGION_CREATE(pGC->pScreen, NullBox, 0);
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
pregWin, pGC->clientClip);
}
pGC->freeCompClip = TRUE;
REGION_TRANSLATE(pGC->pScreen, pGC->clientClip,
-(pDrawable->x + pGC->clipOrg.x),
-(pDrawable->y + pGC->clipOrg.y));
}
} /* end of composite clip for a window */
else {
BoxRec pixbounds;
/* XXX should we translate by drawable.x/y here ? */
pixbounds.x1 = 0;
pixbounds.y1 = 0;
pixbounds.x2 = pDrawable->width;
pixbounds.y2 = pDrawable->height;
if (pGC->freeCompClip) {
REGION_RESET(pGC->pScreen, pGC->pCompositeClip, &pixbounds);
} else {
pGC->freeCompClip = TRUE;
pGC->pCompositeClip = REGION_CREATE(pGC->pScreen, &pixbounds, 1);
}
if (pGC->clientClipType == CT_REGION) {
REGION_TRANSLATE(pGC->pScreen, pGC->pCompositeClip, -pGC->clipOrg.x,
-pGC->clipOrg.y);
REGION_INTERSECT(pGC->pScreen, pGC->pCompositeClip,
pGC->pCompositeClip, pGC->clientClip);
REGION_TRANSLATE(pGC->pScreen, pGC->pCompositeClip, pGC->clipOrg.x,
pGC->clipOrg.y);
}
} /* end of composite clip for pixmap */
} /* end afbComputeCompositeClip */

31
afb/afbimage.c
View File

@ -42,39 +42,8 @@ afbPutImage(pDraw, pGC, depth, x, y, width, height, leftPad, format, pImage)
(void)(*pGC->ops->CopyPlane)((DrawablePtr)pPixmap, pDraw, pGC, leftPad,
0, width, height, x, y, 1);
else {
#if 0
/* XXX: bit plane order wronge ! */
pPixmap->drawable.depth = 1;
pPixmap->drawable.bitsPerPixel = 1;
switch (pGC->alu) {
case GXcopy:
doBitBlt = afbDoBitbltCopy;
break;
case GXxor:
doBitBlt = afbDoBitbltXor;
break;
case GXcopyInverted:
doBitBlt = afbDoBitbltCopyInverted;
break;
case GXor:
doBitBlt = afbDoBitbltOr;
break;
default:
doBitBlt = afbDoBitbltGeneral;
break;
}
for (plane = (1L << (pPixmap->drawable.depth - 1)); plane;
plane >>= 1) {
(void)afbBitBlt((DrawablePtr)pPixmap, pDraw, pGC, leftPad, 0,
width, height, x, y, doBitBlt, plane);
/* pDraw->devKind += sizeDst; */
}
#else
(void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC, leftPad,
0, width, height, x, y);
#endif
}
pGC->fExpose = TRUE;

10
afb/afbpixmap.c
View File

@ -118,9 +118,8 @@ afbDestroyPixmap(pPixmap)
}
PixmapPtr
afbCopyPixmap(pSrc)
register PixmapPtr pSrc;
static PixmapPtr
afbCopyPixmap(PixmapPtr pSrc)
{
register PixmapPtr pDst;
int size;
@ -148,9 +147,8 @@ afbCopyPixmap(pSrc)
zero out area to be filled with replicate
left shift and or in original as many times as needed
*/
void
afbPadPixmap(pPixmap)
PixmapPtr pPixmap;
static void
afbPadPixmap(PixmapPtr pPixmap)
{
register int width = pPixmap->drawable.width;
register int h;

50
afb/afbscrinit.c
View File

@ -77,7 +77,7 @@ int afbScreenPrivateIndex;
static unsigned long afbGeneration = 0;
BSFuncRec afbBSFuncRec = {
static BSFuncRec afbBSFuncRec = {
afbSaveAreas,
afbRestoreAreas,
(BackingStoreSetClipmaskRgnProcPtr) 0,
@ -85,7 +85,7 @@ BSFuncRec afbBSFuncRec = {
(BackingStoreGetSpansPixmapProcPtr) 0,
};
Bool
static Bool
afbCloseScreen(int index, ScreenPtr pScreen)
{
int d;
@ -119,7 +119,29 @@ afbCreateScreenResources(ScreenPtr pScreen)
return(retval);
}
Bool
static PixmapPtr
afbGetWindowPixmap(WindowPtr pWin)
{
#ifdef PIXMAP_PER_WINDOW
return (PixmapPtr)(pWin->devPrivates[frameWindowPrivateIndex].ptr);
#else
ScreenPtr pScreen = pWin->drawable.pScreen;
return (* pScreen->GetScreenPixmap)(pScreen);
#endif
}
static void
afbSetWindowPixmap(WindowPtr pWin, PixmapPtr pPix)
{
#ifdef PIXMAP_PER_WINDOW
pWin->devPrivates[frameWindowPrivateIndex].ptr = (pointer)pPix;
#else
(* pWin->drawable.pScreen->SetScreenPixmap)(pPix);
#endif
}
static Bool
afbAllocatePrivates(ScreenPtr pScreen, int *pWinIndex, int *pGCIndex)
{
if (afbGeneration != serverGeneration) {
@ -216,25 +238,3 @@ afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, i
return TRUE;
}
PixmapPtr
afbGetWindowPixmap(WindowPtr pWin)
{
#ifdef PIXMAP_PER_WINDOW
return (PixmapPtr)(pWin->devPrivates[frameWindowPrivateIndex].ptr);
#else
ScreenPtr pScreen = pWin->drawable.pScreen;
return (* pScreen->GetScreenPixmap)(pScreen);
#endif
}
void
afbSetWindowPixmap(WindowPtr pWin, PixmapPtr pPix)
{
#ifdef PIXMAP_PER_WINDOW
pWin->devPrivates[frameWindowPrivateIndex].ptr = (pointer)pPix;
#else
(* pWin->drawable.pScreen->SetScreenPixmap)(pPix);
#endif
}

18
afb/afbsetsp.c
View File

@ -73,20 +73,10 @@ SOFTWARE.
* boxes, we may not want to start grabbing bits at psrc but at some offset
* further on.)
*/
void
afbSetScanline(y, xOrigin, xStart, xEnd, psrc, alu, pdstBase, widthDst,
sizeDst, depthDst, sizeSrc)
int y;
int xOrigin; /* where this scanline starts */
int xStart; /* first bit to use from scanline */
int xEnd; /* last bit to use from scanline + 1 */
register PixelType *psrc;
register int alu; /* raster op */
PixelType *pdstBase; /* start of the drawable */
int widthDst; /* width of drawable in words */
int sizeDst;
int depthDst;
int sizeSrc;
static void
afbSetScanline(int y, int xOrigin, int xStart, int xEnd, PixelType *psrc,
int alu, PixelType *pdstBase, int widthDst, int sizeDst,
int depthDst, int sizeSrc)
{
int w; /* width of scanline in bits */
register PixelType *pdst; /* where to put the bits */

2
composite/compalloc.c
View File

@ -48,7 +48,7 @@
#include "compint.h"
void
static void
compReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure)
{
WindowPtr pWin = (WindowPtr) closure;

16
composite/compext.c
View File

@ -50,10 +50,10 @@
#include "compint.h"
static CARD8 CompositeReqCode;
int CompositeClientPrivateIndex;
static int CompositeClientPrivateIndex;
RESTYPE CompositeClientWindowType;
RESTYPE CompositeClientSubwindowsType;
RESTYPE CompositeClientOverlayType;
static RESTYPE CompositeClientOverlayType;
static void deleteCompOverlayClient (CompOverlayClientPtr pOcToDel,
ScreenPtr pScreen);
@ -423,7 +423,7 @@ createOverlayWindow (ScreenPtr pScreen)
return pWin;
}
int
static int
ProcCompositeGetOverlayWindow (ClientPtr client)
{
REQUEST(xCompositeGetOverlayWindowReq);
@ -477,7 +477,7 @@ ProcCompositeGetOverlayWindow (ClientPtr client)
return client->noClientException;
}
int
static int
ProcCompositeReleaseOverlayWindow (ClientPtr client)
{
REQUEST(xCompositeReleaseOverlayWindowReq);
@ -515,7 +515,7 @@ ProcCompositeReleaseOverlayWindow (ClientPtr client)
return client->noClientException;
}
int (*ProcCompositeVector[CompositeNumberRequests])(ClientPtr) = {
static int (*ProcCompositeVector[CompositeNumberRequests])(ClientPtr) = {
ProcCompositeQueryVersion,
ProcCompositeRedirectWindow,
ProcCompositeRedirectSubwindows,
@ -625,7 +625,7 @@ SProcCompositeNameWindowPixmap (ClientPtr client)
return (*ProcCompositeVector[stuff->compositeReqType]) (client);
}
int
static int
SProcCompositeGetOverlayWindow (ClientPtr client)
{
int n;
@ -637,7 +637,7 @@ SProcCompositeGetOverlayWindow (ClientPtr client)
return (*ProcCompositeVector[stuff->compositeReqType]) (client);
}
int
static int
SProcCompositeReleaseOverlayWindow (ClientPtr client)
{
int n;
@ -649,7 +649,7 @@ SProcCompositeReleaseOverlayWindow (ClientPtr client)
return (*ProcCompositeVector[stuff->compositeReqType]) (client);
}
int (*SProcCompositeVector[CompositeNumberRequests])(ClientPtr) = {
static int (*SProcCompositeVector[CompositeNumberRequests])(ClientPtr) = {
SProcCompositeQueryVersion,
SProcCompositeRedirectWindow,
SProcCompositeRedirectSubwindows,

2
composite/compinit.c
View File

@ -51,7 +51,7 @@
int CompScreenPrivateIndex;
int CompWindowPrivateIndex;
int CompSubwindowsPrivateIndex;
int CompGeneration;
static int CompGeneration;
static Bool

15
composite/compint.h
View File

@ -171,9 +171,6 @@ extern RESTYPE CompositeClientSubwindowsType;
* compalloc.c
*/
void
compReportDamage (DamagePtr pDamage, RegionPtr pRegion, void *closure);
Bool
compRedirectWindow (ClientPtr pClient, WindowPtr pWin, int update);
@ -292,18 +289,6 @@ compWindowUpdate (WindowPtr pWin);
void
deleteCompOverlayClientsForScreen (ScreenPtr pScreen);
int
ProcCompositeGetOverlayWindow (ClientPtr client);
int
ProcCompositeReleaseOverlayWindow (ClientPtr client);
int
SProcCompositeGetOverlayWindow (ClientPtr client);
int
SProcCompositeReleaseOverlayWindow (ClientPtr client);
WindowPtr
CompositeRealChildHead (WindowPtr pWin);

2
configure.ac
View File

@ -1427,6 +1427,8 @@ return 0;}
fi
if test "${OS_MINOR}" -lt 8 ; then
solaris_usl_console="yes"
else
XORG_CFLAGS="$XORG_CFLAGS -DXF86PM"
fi
;;
*)

18
damageext/damageext.c
View File

@ -28,12 +28,12 @@
#include "damageextint.h"
unsigned char DamageReqCode;
int DamageEventBase;
int DamageErrorBase;
int DamageClientPrivateIndex;
RESTYPE DamageExtType;
RESTYPE DamageExtWinType;
static unsigned char DamageReqCode;
static int DamageEventBase;
static int DamageErrorBase;
static int DamageClientPrivateIndex;
static RESTYPE DamageExtType;
static RESTYPE DamageExtWinType;
/* Version of the damage extension supported by the server, as opposed to the
* DAMAGE_* defines from damageproto for what version the proto header
@ -319,7 +319,7 @@ static const int version_requests[] = {
#define NUM_VERSION_REQUESTS (sizeof (version_requests) / sizeof (version_requests[0]))
int (*ProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
static int (*ProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
/*************** Version 1 ******************/
ProcDamageQueryVersion,
ProcDamageCreate,
@ -408,7 +408,7 @@ SProcDamageAdd (ClientPtr client)
return (*ProcDamageVector[stuff->damageReqType]) (client);
}
int (*SProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
static int (*SProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
/*************** Version 1 ******************/
SProcDamageQueryVersion,
SProcDamageCreate,
@ -478,7 +478,7 @@ FreeDamageExtWin (pointer value, XID wid)
return Success;
}
void
static void
SDamageNotifyEvent (xDamageNotifyEvent *from,
xDamageNotifyEvent *to)
{

14
damageext/damageextint.h
View File

@ -44,13 +44,6 @@
#include "damage.h"
#include "xfixes.h"
extern unsigned char DamageReqCode;
extern int DamageEventBase;
extern int DamageErrorBase;
extern int DamageClientPrivateIndex;
extern RESTYPE DamageExtType;
extern RESTYPE DamageExtWinType;
typedef struct _DamageClient {
CARD32 major_version;
CARD32 minor_version;
@ -67,9 +60,6 @@ typedef struct _DamageExt {
XID id;
} DamageExtRec, *DamageExtPtr;
extern int (*ProcDamageVector[/*XDamageNumberRequests*/])(ClientPtr);
extern int (*SProcDamageVector[/*XDamageNumberRequests*/])(ClientPtr);
#define VERIFY_DAMAGEEXT(pDamageExt, rid, client, mode) { \
pDamageExt = SecurityLookupIDByType (client, rid, DamageExtType, mode); \
if (!pDamageExt) { \
@ -78,10 +68,6 @@ extern int (*SProcDamageVector[/*XDamageNumberRequests*/])(ClientPtr);
} \
}
void
SDamageNotifyEvent (xDamageNotifyEvent *from,
xDamageNotifyEvent *to);
void
DamageExtSetCritical (ClientPtr pClient, Bool critical);

31
dbe/dbe.c
View File

@ -79,36 +79,6 @@ static int dbeErrorBase;
*/
static Bool firstRegistrationPass = TRUE;
/******************************************************************************
*
* DBE DIX Procedure: DbeValidateBuffer
*
* Description:
*
* This function is called from VALIDATE_DRAWABLE_AND_GC and from
* various places in dispatch.c if the server has been compiled with
* the flags -DNEED_DBE_BUF_BITS and -DNEED_DBE_BUF_VALIDATE.
* When pWin->dstBuffer changes, this function will be called with pWin
* as the first argument, the drawable ID that was specified as the
* second argument (could be a back buffer id), and True for the third
* argument.
* When pWin->srcBuffer changes, the third argument will be False, and
* the first two arguments are as described for dstBuffer.
*
* This function should prepare the hardware to access the specified
* buffer for reads (if dstbuf is False) or writes (if dstbuf is True).
*
*****************************************************************************/
void
DbeValidateBuffer(WindowPtr pWin, XID drawID, Bool dstbuf)
{
DbeScreenPrivPtr pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin);
if (pDbeScreenPriv->ValidateBuffer)
(*pDbeScreenPriv->ValidateBuffer)(pWin, drawID, dstbuf);
}
/******************************************************************************
*
@ -317,7 +287,6 @@ DbeStubScreen(DbeScreenPrivPtr pDbeScreenPriv, int *nStubbedScreens)
pDbeScreenPriv->EndIdiom = NULL;
pDbeScreenPriv->WinPrivDelete = NULL;
pDbeScreenPriv->ResetProc = NULL;
pDbeScreenPriv->ValidateBuffer = NULL;
(*nStubbedScreens)++;

5
dbe/dbestruct.h
View File

@ -221,11 +221,6 @@ typedef struct _DbeScreenPrivRec
void (*ResetProc)(
ScreenPtr /*pScreen*/
);
void (*ValidateBuffer)(
WindowPtr /*pWin*/,
XID /*bufId*/,
Bool /*dstbuffer*/
);
/* Device-specific private information.
*/

25
dbe/midbe.c
View File

@ -59,21 +59,12 @@
#include <stdio.h>
/* DEFINES */
/* TYPEDEFS */
/* GLOBALS */
static int miDbePrivPrivGeneration = 0;
static int miDbeWindowPrivPrivIndex = -1;
RESTYPE dbeDrawableResType;
RESTYPE dbeWindowPrivResType;
int dbeScreenPrivIndex = -1;
int dbeWindowPrivIndex = -1;
static RESTYPE dbeDrawableResType;
static RESTYPE dbeWindowPrivResType;
static int dbeScreenPrivIndex = -1;
static int dbeWindowPrivIndex = -1;
/******************************************************************************
@ -768,11 +759,6 @@ miDbeResetProc(ScreenPtr pScreen)
} /* miDbeResetProc() */
static void
miDbeNopValidateBuffer(WindowPtr pWin, XID bufId, Bool dstbuffer)
{
}
/******************************************************************************
*
@ -830,9 +816,6 @@ miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv)
pDbeScreenPriv->ResetProc = miDbeResetProc;
pDbeScreenPriv->WinPrivDelete = miDbeWinPrivDelete;
/* The mi implementation doesn't need buffer validation. */
pDbeScreenPriv->ValidateBuffer = miDbeNopValidateBuffer;
return(TRUE);
} /* miDbeInit() */

8
dix/atom.c
View File

@ -77,10 +77,10 @@ void FreeAtom(NodePtr patom);
_X_EXPORT Atom
MakeAtom(char *string, unsigned len, Bool makeit)
{
register NodePtr * np;
NodePtr * np;
unsigned i;
int comp;
register unsigned int fp = 0;
int comp;
unsigned int fp = 0;
np = &atomRoot;
for (i = 0; i < (len+1)/2; i++)
@ -107,7 +107,7 @@ MakeAtom(char *string, unsigned len, Bool makeit)
}
if (makeit)
{
register NodePtr nd;
NodePtr nd;
nd = (NodePtr) xalloc(sizeof(NodeRec));
if (!nd)

56
dix/colormap.c
View File

@ -95,8 +95,8 @@ static int BlueComp(
);
static void FreePixels(
register ColormapPtr /*pmap*/,
register int /*client*/
ColormapPtr /*pmap*/,
int /*client*/
);
static void CopyFree(
@ -259,9 +259,9 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
int class, size;
unsigned long sizebytes;
ColormapPtr pmap;
register EntryPtr pent;
EntryPtr pent;
int i;
register Pixel *ppix, **pptr;
Pixel *ppix, **pptr;
class = pVisual->class;
if(!(class & DynamicClass) && (alloc != AllocNone) && (client != SERVER_ID))
@ -428,8 +428,8 @@ CreateColormap (Colormap mid, ScreenPtr pScreen, VisualPtr pVisual,
int
FreeColormap (pointer value, XID mid)
{
int i;
register EntryPtr pent;
int i;
EntryPtr pent;
ColormapPtr pmap = (ColormapPtr)value;
if(CLIENT_ID(mid) != SERVER_ID)
@ -744,9 +744,9 @@ static void
UpdateColors (ColormapPtr pmap)
{
xColorItem *defs;
register xColorItem *pdef;
register EntryPtr pent;
register VisualPtr pVisual;
xColorItem *pdef;
EntryPtr pent;
VisualPtr pVisual;
int i, n, size;
pVisual = pmap->pVisual;
@ -993,14 +993,14 @@ AllocColor (ColormapPtr pmap,
*/
_X_EXPORT void
FakeAllocColor (register ColormapPtr pmap, register xColorItem *item)
FakeAllocColor (ColormapPtr pmap, xColorItem *item)
{
Pixel pixR, pixG, pixB;
Pixel temp;
int entries;
xrgb rgb;
int class;
register VisualPtr pVisual;
Pixel pixR, pixG, pixB;
Pixel temp;
int entries;
xrgb rgb;
int class;
VisualPtr pVisual;
pVisual = pmap->pVisual;
rgb.red = item->red;
@ -1059,9 +1059,9 @@ FakeAllocColor (register ColormapPtr pmap, register xColorItem *item)
/* free a pixel value obtained from FakeAllocColor */
_X_EXPORT void
FakeFreeColor(register ColormapPtr pmap, Pixel pixel)
FakeFreeColor(ColormapPtr pmap, Pixel pixel)
{
register VisualPtr pVisual;
VisualPtr pVisual;
Pixel pixR, pixG, pixB;
switch (pmap->class) {
@ -1507,11 +1507,11 @@ QueryColors (ColormapPtr pmap, int count, Pixel *ppixIn, xrgb *prgbList)
}
static void
FreePixels(register ColormapPtr pmap, register int client)
FreePixels(ColormapPtr pmap, int client)
{
register Pixel *ppix, *ppixStart;
register int n;
int class;
Pixel *ppix, *ppixStart;
int n;
int class;
class = pmap->class;
ppixStart = pmap->clientPixelsRed[client];
@ -1646,8 +1646,8 @@ AllocColorPlanes (int client, ColormapPtr pmap, int colors,
{
int ok;
Pixel mask, *ppixFirst;
register Pixel shift;
register int i;
Pixel shift;
int i;
int class;
int oldcount;
colorResource *pcr = (colorResource *)NULL;
@ -2409,10 +2409,10 @@ FreeCo (ColormapPtr pmap, int client, int color, int npixIn, Pixel *ppixIn, Pixe
_X_EXPORT int
StoreColors (ColormapPtr pmap, int count, xColorItem *defs)
{
register Pixel pix;
register xColorItem *pdef;
register EntryPtr pent, pentT, pentLast;
register VisualPtr pVisual;
Pixel pix;
xColorItem *pdef;
EntryPtr pent, pentT, pentLast;
VisualPtr pVisual;
SHAREDCOLOR *pred, *pgreen, *pblue;
int n, ChgRed, ChgGreen, ChgBlue, idef;
int class, errVal = Success;

8
dix/cursor.c
View File

@ -86,7 +86,7 @@ FreeCursorBits(CursorBitsPtr bits)
#endif
if (bits->refcnt == 0)
{
register GlyphSharePtr *prev, this;
GlyphSharePtr *prev, this;
for (prev = &sharedGlyphs;
(this = *prev) && (this->bits != bits);
@ -135,7 +135,7 @@ FreeCursor(pointer value, XID cid)
static void
CheckForEmptyMask(CursorBitsPtr bits)
{
register unsigned char *msk = bits->mask;
unsigned char *msk = bits->mask;
int n = BitmapBytePad(bits->width) * bits->height;
bits->emptyMask = FALSE;
@ -305,8 +305,8 @@ AllocGlyphCursor(Font source, unsigned sourceChar, Font mask, unsigned maskChar,
}
if (!maskfont)
{
register long n;
register unsigned char *mskptr;
long n;
unsigned char *mskptr;
n = BitmapBytePad(cm.width)*(long)cm.height;
mskptr = mskbits = (unsigned char *)xalloc(n);

86
dix/devices.c
View File

@ -67,7 +67,7 @@ SOFTWARE.
#define XKB_IN_SERVER
#endif
#ifdef XKB
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#endif
#include "xace.h"
@ -79,12 +79,13 @@ SOFTWARE.
#include "exglobals.h"
#include "exevents.h"
int CoreDevicePrivatesIndex = 0, CoreDevicePrivatesGeneration = -1;
int CoreDevicePrivatesIndex = 0;
static int CoreDevicePrivatesGeneration = -1;
DeviceIntPtr
AddInputDevice(DeviceProc deviceProc, Bool autoStart)
{
register DeviceIntPtr dev, *prev; /* not a typo */
DeviceIntPtr dev, *prev; /* not a typo */
if (inputInfo.numDevices >= MAX_DEVICES)
return (DeviceIntPtr)NULL;
@ -147,9 +148,9 @@ AddInputDevice(DeviceProc deviceProc, Bool autoStart)
}
Bool
EnableDevice(register DeviceIntPtr dev)
EnableDevice(DeviceIntPtr dev)
{
register DeviceIntPtr *prev;
DeviceIntPtr *prev;
int ret;
for (prev = &inputInfo.off_devices;
@ -173,9 +174,9 @@ EnableDevice(register DeviceIntPtr dev)
}
Bool
DisableDevice(register DeviceIntPtr dev)
DisableDevice(DeviceIntPtr dev)
{
register DeviceIntPtr *prev;
DeviceIntPtr *prev;
for (prev = &inputInfo.devices;
*prev && (*prev != dev);
@ -245,7 +246,7 @@ CoreKeyboardProc(DeviceIntPtr pDev, int what)
keySyms.mapWidth = 4;
keySyms.map = (KeySym *)xcalloc(sizeof(KeySym),
(keySyms.maxKeyCode -
keySyms.minKeyCode) *
keySyms.minKeyCode + 1) *
keySyms.mapWidth);
if (!keySyms.map) {
ErrorF("Couldn't allocate core keymap\n");
@ -322,7 +323,7 @@ CorePointerProc(DeviceIntPtr pDev, int what)
void
InitCoreDevices()
{
register DeviceIntPtr dev;
DeviceIntPtr dev;
if (CoreDevicePrivatesGeneration != serverGeneration) {
CoreDevicePrivatesIndex = AllocateDevicePrivateIndex();
@ -381,7 +382,7 @@ InitCoreDevices()
int
InitAndStartDevices()
{
register DeviceIntPtr dev, next;
DeviceIntPtr dev, next;
for (dev = inputInfo.off_devices; dev; dev = dev->next) {
DebugF("(dix) initialising device %d\n", dev->id);
@ -413,7 +414,7 @@ InitAndStartDevices()
}
static void
CloseDevice(register DeviceIntPtr dev)
CloseDevice(DeviceIntPtr dev)
{
KbdFeedbackPtr k, knext;
PtrFeedbackPtr p, pnext;
@ -501,6 +502,9 @@ CloseDevice(register DeviceIntPtr dev)
XkbRemoveResourceClient((DevicePtr)dev,dev->xkb_interest->resource);
#endif
if (dev->devPrivates)
xfree(dev->devPrivates);
xfree(dev->sync.event);
xfree(dev);
}
@ -508,7 +512,7 @@ CloseDevice(register DeviceIntPtr dev)
void
CloseDownDevices()
{
register DeviceIntPtr dev, next;
DeviceIntPtr dev, next;
for (dev = inputInfo.devices; dev; dev = next)
{
@ -638,7 +642,7 @@ QueryMinMaxKeyCodes(KeyCode *minCode, KeyCode *maxCode)
}
Bool
SetKeySymsMap(register KeySymsPtr dst, register KeySymsPtr src)
SetKeySymsMap(KeySymsPtr dst, KeySymsPtr src)
{
int i, j;
int rowDif = src->minKeyCode - dst->minKeyCode;
@ -687,7 +691,7 @@ SetKeySymsMap(register KeySymsPtr dst, register KeySymsPtr src)
}
static Bool
InitModMap(register KeyClassPtr keyc)
InitModMap(KeyClassPtr keyc)
{
int i, j;
CARD8 keysPerModifier[8];
@ -732,7 +736,7 @@ _X_EXPORT Bool
InitKeyClassDeviceStruct(DeviceIntPtr dev, KeySymsPtr pKeySyms, CARD8 pModifiers[])
{
int i;
register KeyClassPtr keyc;
KeyClassPtr keyc;
keyc = (KeyClassPtr)xalloc(sizeof(KeyClassRec));
if (!keyc)
@ -767,10 +771,10 @@ InitKeyClassDeviceStruct(DeviceIntPtr dev, KeySymsPtr pKeySyms, CARD8 pModifiers
}
_X_EXPORT Bool
InitButtonClassDeviceStruct(register DeviceIntPtr dev, int numButtons,
InitButtonClassDeviceStruct(DeviceIntPtr dev, int numButtons,
CARD8 *map)
{
register ButtonClassPtr butc;
ButtonClassPtr butc;
int i;
butc = (ButtonClassPtr)xalloc(sizeof(ButtonClassRec));
@ -796,7 +800,7 @@ InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes,
int numMotionEvents, int mode)
{
int i;
register ValuatorClassPtr valc;
ValuatorClassPtr valc;
if (!dev)
return FALSE;
@ -838,7 +842,7 @@ InitValuatorClassDeviceStruct(DeviceIntPtr dev, int numAxes,
_X_EXPORT Bool
InitAbsoluteClassDeviceStruct(DeviceIntPtr dev)
{
register AbsoluteClassPtr abs;
AbsoluteClassPtr abs;
abs = (AbsoluteClassPtr)xalloc(sizeof(AbsoluteClassRec));
if (!abs)
@ -868,7 +872,7 @@ InitAbsoluteClassDeviceStruct(DeviceIntPtr dev)
_X_EXPORT Bool
InitFocusClassDeviceStruct(DeviceIntPtr dev)
{
register FocusClassPtr focc;
FocusClassPtr focc;
focc = (FocusClassPtr)xalloc(sizeof(FocusClassRec));
if (!focc)
@ -887,7 +891,7 @@ _X_EXPORT Bool
InitKbdFeedbackClassDeviceStruct(DeviceIntPtr dev, BellProcPtr bellProc,
KbdCtrlProcPtr controlProc)
{
register KbdFeedbackPtr feedc;
KbdFeedbackPtr feedc;
feedc = (KbdFeedbackPtr)xalloc(sizeof(KbdFeedbackClassRec));
if (!feedc)
@ -914,7 +918,7 @@ InitKbdFeedbackClassDeviceStruct(DeviceIntPtr dev, BellProcPtr bellProc,
_X_EXPORT Bool
InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
{
register PtrFeedbackPtr feedc;
PtrFeedbackPtr feedc;
feedc = (PtrFeedbackPtr)xalloc(sizeof(PtrFeedbackClassRec));
if (!feedc)
@ -930,16 +934,16 @@ InitPtrFeedbackClassDeviceStruct(DeviceIntPtr dev, PtrCtrlProcPtr controlProc)
}
LedCtrl defaultLedControl = {
static LedCtrl defaultLedControl = {
DEFAULT_LEDS, DEFAULT_LEDS_MASK, 0};
BellCtrl defaultBellControl = {
static BellCtrl defaultBellControl = {
DEFAULT_BELL,
DEFAULT_BELL_PITCH,
DEFAULT_BELL_DURATION,
0};
IntegerCtrl defaultIntegerControl = {
static IntegerCtrl defaultIntegerControl = {
DEFAULT_INT_RESOLUTION,
DEFAULT_INT_MIN_VALUE,
DEFAULT_INT_MAX_VALUE,
@ -952,7 +956,7 @@ InitStringFeedbackClassDeviceStruct (
int max_symbols, int num_symbols_supported, KeySym *symbols)
{
int i;
register StringFeedbackPtr feedc;
StringFeedbackPtr feedc;
feedc = (StringFeedbackPtr)xalloc(sizeof(StringFeedbackClassRec));
if (!feedc)
@ -990,7 +994,7 @@ _X_EXPORT Bool
InitBellFeedbackClassDeviceStruct (DeviceIntPtr dev, BellProcPtr bellProc,
BellCtrlProcPtr controlProc)
{
register BellFeedbackPtr feedc;
BellFeedbackPtr feedc;
feedc = (BellFeedbackPtr)xalloc(sizeof(BellFeedbackClassRec));
if (!feedc)
@ -1009,7 +1013,7 @@ InitBellFeedbackClassDeviceStruct (DeviceIntPtr dev, BellProcPtr bellProc,
_X_EXPORT Bool
InitLedFeedbackClassDeviceStruct (DeviceIntPtr dev, LedCtrlProcPtr controlProc)
{
register LedFeedbackPtr feedc;
LedFeedbackPtr feedc;
feedc = (LedFeedbackPtr)xalloc(sizeof(LedFeedbackClassRec));
if (!feedc)
@ -1030,7 +1034,7 @@ InitLedFeedbackClassDeviceStruct (DeviceIntPtr dev, LedCtrlProcPtr controlProc)
_X_EXPORT Bool
InitIntegerFeedbackClassDeviceStruct (DeviceIntPtr dev, IntegerCtrlProcPtr controlProc)
{
register IntegerFeedbackPtr feedc;
IntegerFeedbackPtr feedc;
feedc = (IntegerFeedbackPtr)xalloc(sizeof(IntegerFeedbackClassRec));
if (!feedc)
@ -1116,9 +1120,9 @@ SendMappingNotify(unsigned request, unsigned firstKeyCode, unsigned count,
* sort it to do the checking. How often is it called? Just being lazy?
*/
Bool
BadDeviceMap(register BYTE *buff, int length, unsigned low, unsigned high, XID *errval)
BadDeviceMap(BYTE *buff, int length, unsigned low, unsigned high, XID *errval)
{
register int i, j;
int i, j;
for (i = 0; i < length; i++)
if (buff[i]) /* only check non-zero elements */
@ -1140,12 +1144,12 @@ BadDeviceMap(register BYTE *buff, int length, unsigned low, unsigned high, XID *
Bool
AllModifierKeysAreUp(dev, map1, per1, map2, per2)
register DeviceIntPtr dev;
register CARD8 *map1, *map2;
DeviceIntPtr dev;
CARD8 *map1, *map2;
int per1, per2;
{
register int i, j, k;
register CARD8 *down = dev->key->down;
int i, j, k;
CARD8 *down = dev->key->down;
for (i = 8; --i >= 0; map2 += per2)
{
@ -1262,7 +1266,7 @@ int
ProcGetModifierMapping(ClientPtr client)
{
xGetModifierMappingReply rep;
register KeyClassPtr keyc = inputInfo.keyboard->key;
KeyClassPtr keyc = inputInfo.keyboard->key;
REQUEST_SIZE_MATCH(xReq);
rep.type = X_Reply;
@ -1463,7 +1467,7 @@ NoteLedState(DeviceIntPtr keybd, int led, Bool on)
_X_EXPORT int
Ones(unsigned long mask) /* HACKMEM 169 */
{
register unsigned long y;
unsigned long y;
y = (mask >> 1) &033333333333;
y = mask - y - ((y >>1) & 033333333333);
@ -1680,7 +1684,7 @@ int
ProcGetKeyboardControl (ClientPtr client)
{
int i;
register KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl;
KeybdCtrl *ctrl = &inputInfo.keyboard->kbdfeed->ctrl;
xGetKeyboardControlReply rep;
REQUEST_SIZE_MATCH(xReq);
@ -1702,7 +1706,7 @@ ProcGetKeyboardControl (ClientPtr client)
int
ProcBell(ClientPtr client)
{
register DeviceIntPtr keybd = inputInfo.keyboard;
DeviceIntPtr keybd = inputInfo.keyboard;
int base = keybd->kbdfeed->ctrl.bell;
int newpercent;
REQUEST(xBellReq);
@ -1811,7 +1815,7 @@ ProcChangePointerControl(ClientPtr client)
int
ProcGetPointerControl(ClientPtr client)
{
register PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl;
PtrCtrl *ctrl = &inputInfo.pointer->ptrfeed->ctrl;
xGetPointerControlReply rep;
REQUEST_SIZE_MATCH(xReq);
@ -1826,7 +1830,7 @@ ProcGetPointerControl(ClientPtr client)
}
void
MaybeStopHint(register DeviceIntPtr dev, ClientPtr client)
MaybeStopHint(DeviceIntPtr dev, ClientPtr client)
{
GrabPtr grab = dev->grab;

305
dix/dispatch.c
View File

@ -143,7 +143,7 @@ int ProcInitialConnection();
#define XKB_IN_SERVER
#endif
#include "inputstr.h"
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#endif
#ifdef XSERVER_DTRACE
@ -262,7 +262,7 @@ void
FlushClientCaches(XID id)
{
int i;
register ClientPtr client;
ClientPtr client;
client = clients[CLIENT_ID(id)];
if (client == NullClient)
@ -297,9 +297,8 @@ long SmartScheduleSlice = SMART_SCHEDULE_DEFAULT_INTERVAL;
long SmartScheduleInterval = SMART_SCHEDULE_DEFAULT_INTERVAL;
long SmartScheduleMaxSlice = SMART_SCHEDULE_MAX_SLICE;
long SmartScheduleTime;
ClientPtr SmartLastClient;
int SmartLastIndex[SMART_MAX_PRIORITY-SMART_MIN_PRIORITY+1];
int SmartScheduleClient(int *clientReady, int nready);
static ClientPtr SmartLastClient;
static int SmartLastIndex[SMART_MAX_PRIORITY-SMART_MIN_PRIORITY+1];
#ifdef SMART_DEBUG
long SmartLastPrint;
@ -308,7 +307,7 @@ long SmartLastPrint;
void Dispatch(void);
void InitProcVectors(void);
int
static int
SmartScheduleClient (int *clientReady, int nready)
{
ClientPtr pClient;
@ -394,11 +393,11 @@ SmartScheduleClient (int *clientReady, int nready)
void
Dispatch(void)
{
register int *clientReady; /* array of request ready clients */
register int result;
register ClientPtr client;
register int nready;
register HWEventQueuePtr* icheck = checkForInput;
int *clientReady; /* array of request ready clients */
int result;
ClientPtr client;
int nready;
HWEventQueuePtr* icheck = checkForInput;
#ifdef SMART_SCHEDULE
long start_tick;
#endif
@ -594,11 +593,11 @@ ProcCreateWindow(ClientPtr client)
}
int
ProcChangeWindowAttributes(register ClientPtr client)
ProcChangeWindowAttributes(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xChangeWindowAttributesReq);
register int result;
int result;
int len, rc;
REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
@ -619,7 +618,7 @@ ProcChangeWindowAttributes(register ClientPtr client)
}
int
ProcGetWindowAttributes(register ClientPtr client)
ProcGetWindowAttributes(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -636,7 +635,7 @@ ProcGetWindowAttributes(register ClientPtr client)
}
int
ProcDestroyWindow(register ClientPtr client)
ProcDestroyWindow(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -652,7 +651,7 @@ ProcDestroyWindow(register ClientPtr client)
}
int
ProcDestroySubwindows(register ClientPtr client)
ProcDestroySubwindows(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -667,11 +666,11 @@ ProcDestroySubwindows(register ClientPtr client)
}
int
ProcChangeSaveSet(register ClientPtr client)
ProcChangeSaveSet(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xChangeSaveSetReq);
register int result, rc;
int result, rc;
REQUEST_SIZE_MATCH(xChangeSaveSetReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess);
@ -695,11 +694,11 @@ ProcChangeSaveSet(register ClientPtr client)
}
int
ProcReparentWindow(register ClientPtr client)
ProcReparentWindow(ClientPtr client)
{
WindowPtr pWin, pParent;
REQUEST(xReparentWindowReq);
register int result, rc;
int result, rc;
REQUEST_SIZE_MATCH(xReparentWindowReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixWriteAccess);
@ -728,7 +727,7 @@ ProcReparentWindow(register ClientPtr client)
}
int
ProcMapWindow(register ClientPtr client)
ProcMapWindow(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -744,7 +743,7 @@ ProcMapWindow(register ClientPtr client)
}
int
ProcMapSubwindows(register ClientPtr client)
ProcMapSubwindows(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -760,7 +759,7 @@ ProcMapSubwindows(register ClientPtr client)
}
int
ProcUnmapWindow(register ClientPtr client)
ProcUnmapWindow(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -776,7 +775,7 @@ ProcUnmapWindow(register ClientPtr client)
}
int
ProcUnmapSubwindows(register ClientPtr client)
ProcUnmapSubwindows(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xResourceReq);
@ -791,11 +790,11 @@ ProcUnmapSubwindows(register ClientPtr client)
}
int
ProcConfigureWindow(register ClientPtr client)
ProcConfigureWindow(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xConfigureWindowReq);
register int result;
int result;
int len, rc;
REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
@ -814,7 +813,7 @@ ProcConfigureWindow(register ClientPtr client)
}
int
ProcCirculateWindow(register ClientPtr client)
ProcCirculateWindow(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xCirculateWindowReq);
@ -834,8 +833,8 @@ ProcCirculateWindow(register ClientPtr client)
return(client->noClientException);
}
int
GetGeometry(register ClientPtr client, xGetGeometryReply *rep)
static int
GetGeometry(ClientPtr client, xGetGeometryReply *rep)
{
DrawablePtr pDraw;
int rc;
@ -865,7 +864,7 @@ GetGeometry(register ClientPtr client, xGetGeometryReply *rep)
if ((pDraw->type == UNDRAWABLE_WINDOW) ||
((pDraw->type == DRAWABLE_WINDOW) && (stuff->id == pDraw->id)))
{
register WindowPtr pWin = (WindowPtr)pDraw;
WindowPtr pWin = (WindowPtr)pDraw;
rep->x = pWin->origin.x - wBorderWidth (pWin);
rep->y = pWin->origin.y - wBorderWidth (pWin);
rep->borderWidth = pWin->borderWidth;
@ -880,7 +879,7 @@ GetGeometry(register ClientPtr client, xGetGeometryReply *rep)
int
ProcGetGeometry(register ClientPtr client)
ProcGetGeometry(ClientPtr client)
{
xGetGeometryReply rep;
int status;
@ -894,7 +893,7 @@ ProcGetGeometry(register ClientPtr client)
int
ProcQueryTree(register ClientPtr client)
ProcQueryTree(ClientPtr client)
{
xQueryTreeReply reply;
int rc, numChildren = 0;
@ -942,7 +941,7 @@ ProcQueryTree(register ClientPtr client)
}
int
ProcInternAtom(register ClientPtr client)
ProcInternAtom(ClientPtr client)
{
Atom atom;
char *tchar;
@ -971,7 +970,7 @@ ProcInternAtom(register ClientPtr client)
}
int
ProcGetAtomName(register ClientPtr client)
ProcGetAtomName(ClientPtr client)
{
char *str;
xGetAtomNameReply reply;
@ -1002,7 +1001,7 @@ extern int k5_bad();
#endif
int
ProcSetSelectionOwner(register ClientPtr client)
ProcSetSelectionOwner(ClientPtr client)
{
WindowPtr pWin;
TimeStamp time;
@ -1102,7 +1101,7 @@ ProcSetSelectionOwner(register ClientPtr client)
}
int
ProcGetSelectionOwner(register ClientPtr client)
ProcGetSelectionOwner(ClientPtr client)
{
REQUEST(xResourceReq);
@ -1135,7 +1134,7 @@ ProcGetSelectionOwner(register ClientPtr client)
}
int
ProcConvertSelection(register ClientPtr client)
ProcConvertSelection(ClientPtr client)
{
Bool paramsOkay;
xEvent event;
@ -1193,7 +1192,7 @@ ProcConvertSelection(register ClientPtr client)
}
int
ProcGrabServer(register ClientPtr client)
ProcGrabServer(ClientPtr client)
{
REQUEST_SIZE_MATCH(xReq);
if (grabState != GrabNone && client != grabClient)
@ -1247,7 +1246,7 @@ UngrabServer(ClientPtr client)
}
int
ProcUngrabServer(register ClientPtr client)
ProcUngrabServer(ClientPtr client)
{
REQUEST_SIZE_MATCH(xReq);
UngrabServer(client);
@ -1255,7 +1254,7 @@ ProcUngrabServer(register ClientPtr client)
}
int
ProcTranslateCoords(register ClientPtr client)
ProcTranslateCoords(ClientPtr client)
{
REQUEST(xTranslateCoordsReq);
@ -1332,7 +1331,7 @@ ProcTranslateCoords(register ClientPtr client)
}
int
ProcOpenFont(register ClientPtr client)
ProcOpenFont(ClientPtr client)
{
int err;
REQUEST(xOpenFontReq);
@ -1351,7 +1350,7 @@ ProcOpenFont(register ClientPtr client)
}
int
ProcCloseFont(register ClientPtr client)
ProcCloseFont(ClientPtr client)
{
FontPtr pFont;
REQUEST(xResourceReq);
@ -1372,11 +1371,11 @@ ProcCloseFont(register ClientPtr client)
}
int
ProcQueryFont(register ClientPtr client)
ProcQueryFont(ClientPtr client)
{
xQueryFontReply *reply;
FontPtr pFont;
register GC *pGC;
GC *pGC;
REQUEST(xResourceReq);
REQUEST_SIZE_MATCH(xResourceReq);
@ -1430,7 +1429,7 @@ ProcQueryFont(register ClientPtr client)
}
int
ProcQueryTextExtents(register ClientPtr client)
ProcQueryTextExtents(ClientPtr client)
{
REQUEST(xQueryTextExtentsReq);
xQueryTextExtentsReply reply;
@ -1480,7 +1479,7 @@ ProcQueryTextExtents(register ClientPtr client)
}
int
ProcListFonts(register ClientPtr client)
ProcListFonts(ClientPtr client)
{
REQUEST(xListFontsReq);
@ -1491,7 +1490,7 @@ ProcListFonts(register ClientPtr client)
}
int
ProcListFontsWithInfo(register ClientPtr client)
ProcListFontsWithInfo(ClientPtr client)
{
REQUEST(xListFontsWithInfoReq);
@ -1513,13 +1512,13 @@ dixDestroyPixmap(pointer value, XID pid)
}
int
ProcCreatePixmap(register ClientPtr client)
ProcCreatePixmap(ClientPtr client)
{
PixmapPtr pMap;
DrawablePtr pDraw;
REQUEST(xCreatePixmapReq);
DepthPtr pDepth;
register int i, rc;
int i, rc;
REQUEST_SIZE_MATCH(xCreatePixmapReq);
client->errorValue = stuff->pid;
@ -1576,7 +1575,7 @@ CreatePmap:
}
int
ProcFreePixmap(register ClientPtr client)
ProcFreePixmap(ClientPtr client)
{
PixmapPtr pMap;
@ -1598,7 +1597,7 @@ ProcFreePixmap(register ClientPtr client)
}
int
ProcCreateGC(register ClientPtr client)
ProcCreateGC(ClientPtr client)
{
int error, rc;
GC *pGC;
@ -1626,7 +1625,7 @@ ProcCreateGC(register ClientPtr client)
}
int
ProcChangeGC(register ClientPtr client)
ProcChangeGC(ClientPtr client)
{
GC *pGC;
int result;
@ -1653,7 +1652,7 @@ ProcChangeGC(register ClientPtr client)
}
int
ProcCopyGC(register ClientPtr client)
ProcCopyGC(ClientPtr client)
{
GC *dstGC;
GC *pGC;
@ -1680,7 +1679,7 @@ ProcCopyGC(register ClientPtr client)
}
int
ProcSetDashes(register ClientPtr client)
ProcSetDashes(ClientPtr client)
{
GC *pGC;
int result;
@ -1709,7 +1708,7 @@ ProcSetDashes(register ClientPtr client)
}
int
ProcSetClipRectangles(register ClientPtr client)
ProcSetClipRectangles(ClientPtr client)
{
int nr, result;
GC *pGC;
@ -1739,7 +1738,7 @@ ProcSetClipRectangles(register ClientPtr client)
}
int
ProcFreeGC(register ClientPtr client)
ProcFreeGC(ClientPtr client)
{
GC *pGC;
int rc;
@ -1755,7 +1754,7 @@ ProcFreeGC(register ClientPtr client)
}
int
ProcClearToBackground(register ClientPtr client)
ProcClearToBackground(ClientPtr client)
{
REQUEST(xClearAreaReq);
WindowPtr pWin;
@ -1782,7 +1781,7 @@ ProcClearToBackground(register ClientPtr client)
}
int
ProcCopyArea(register ClientPtr client)
ProcCopyArea(ClientPtr client)
{
DrawablePtr pDst;
DrawablePtr pSrc;
@ -1809,8 +1808,6 @@ ProcCopyArea(register ClientPtr client)
else
pSrc = pDst;
SET_DBE_SRCBUF(pSrc, stuff->srcDrawable);
pRgn = (*pGC->ops->CopyArea)(pSrc, pDst, pGC, stuff->srcX, stuff->srcY,
stuff->width, stuff->height,
stuff->dstX, stuff->dstY);
@ -1826,7 +1823,7 @@ ProcCopyArea(register ClientPtr client)
}
int
ProcCopyPlane(register ClientPtr client)
ProcCopyPlane(ClientPtr client)
{
DrawablePtr psrcDraw, pdstDraw;
GC *pGC;
@ -1853,8 +1850,6 @@ ProcCopyPlane(register ClientPtr client)
else
psrcDraw = pdstDraw;
SET_DBE_SRCBUF(psrcDraw, stuff->srcDrawable);
/* Check to see if stuff->bitPlane has exactly ONE good bit set */
if(stuff->bitPlane == 0 || (stuff->bitPlane & (stuff->bitPlane - 1)) ||
(stuff->bitPlane > (1L << (psrcDraw->depth - 1))))
@ -1877,7 +1872,7 @@ ProcCopyPlane(register ClientPtr client)
}
int
ProcPolyPoint(register ClientPtr client)
ProcPolyPoint(ClientPtr client)
{
int npoint;
GC *pGC;
@ -1900,7 +1895,7 @@ ProcPolyPoint(register ClientPtr client)
}
int
ProcPolyLine(register ClientPtr client)
ProcPolyLine(ClientPtr client)
{
int npoint;
GC *pGC;
@ -1923,7 +1918,7 @@ ProcPolyLine(register ClientPtr client)
}
int
ProcPolySegment(register ClientPtr client)
ProcPolySegment(ClientPtr client)
{
int nsegs;
GC *pGC;
@ -1942,7 +1937,7 @@ ProcPolySegment(register ClientPtr client)
}
int
ProcPolyRectangle (register ClientPtr client)
ProcPolyRectangle (ClientPtr client)
{
int nrects;
GC *pGC;
@ -1962,7 +1957,7 @@ ProcPolyRectangle (register ClientPtr client)
}
int
ProcPolyArc(register ClientPtr client)
ProcPolyArc(ClientPtr client)
{
int narcs;
GC *pGC;
@ -1981,7 +1976,7 @@ ProcPolyArc(register ClientPtr client)
}
int
ProcFillPoly(register ClientPtr client)
ProcFillPoly(ClientPtr client)
{
int things;
GC *pGC;
@ -2012,7 +2007,7 @@ ProcFillPoly(register ClientPtr client)
}
int
ProcPolyFillRectangle(register ClientPtr client)
ProcPolyFillRectangle(ClientPtr client)
{
int things;
GC *pGC;
@ -2033,7 +2028,7 @@ ProcPolyFillRectangle(register ClientPtr client)
}
int
ProcPolyFillArc(register ClientPtr client)
ProcPolyFillArc(ClientPtr client)
{
int narcs;
GC *pGC;
@ -2106,7 +2101,7 @@ ReformatImage (char *base, int nbytes, int bpp, int order)
* boundary, even if the scanlines are padded to our satisfaction.
*/
int
ProcPutImage(register ClientPtr client)
ProcPutImage(ClientPtr client)
{
GC *pGC;
DrawablePtr pDraw;
@ -2162,15 +2157,14 @@ ProcPutImage(register ClientPtr client)
return (client->noClientException);
}
int
DoGetImage(register ClientPtr client, int format, Drawable drawable,
static int
DoGetImage(ClientPtr client, int format, Drawable drawable,
int x, int y, int width, int height,
Mask planemask, xGetImageReply **im_return)
{
DrawablePtr pDraw;
int nlines, linesPerBuf, rc;
register int linesDone;
int linesDone;
long widthBytesLine, length;
Mask plane = 0;
char *pBuf;
@ -2215,8 +2209,6 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
xgi.visual = None;
}
SET_DBE_SRCBUF(pDraw, drawable);
xgi.type = X_Reply;
xgi.sequenceNumber = client->sequence;
xgi.depth = pDraw->depth;
@ -2384,7 +2376,7 @@ DoGetImage(register ClientPtr client, int format, Drawable drawable,
}
int
ProcGetImage(register ClientPtr client)
ProcGetImage(ClientPtr client)
{
REQUEST(xGetImageReq);
@ -2397,7 +2389,7 @@ ProcGetImage(register ClientPtr client)
}
int
ProcPolyText(register ClientPtr client)
ProcPolyText(ClientPtr client)
{
int err;
REQUEST(xPolyTextReq);
@ -2426,7 +2418,7 @@ ProcPolyText(register ClientPtr client)
}
int
ProcImageText8(register ClientPtr client)
ProcImageText8(ClientPtr client)
{
int err;
DrawablePtr pDraw;
@ -2456,7 +2448,7 @@ ProcImageText8(register ClientPtr client)
}
int
ProcImageText16(register ClientPtr client)
ProcImageText16(ClientPtr client)
{
int err;
DrawablePtr pDraw;
@ -2487,7 +2479,7 @@ ProcImageText16(register ClientPtr client)
int
ProcCreateColormap(register ClientPtr client)
ProcCreateColormap(ClientPtr client)
{
VisualPtr pVisual;
ColormapPtr pmap;
@ -2529,7 +2521,7 @@ ProcCreateColormap(register ClientPtr client)
}
int
ProcFreeColormap(register ClientPtr client)
ProcFreeColormap(ClientPtr client)
{
ColormapPtr pmap;
REQUEST(xResourceReq);
@ -2553,7 +2545,7 @@ ProcFreeColormap(register ClientPtr client)
int
ProcCopyColormapAndFree(register ClientPtr client)
ProcCopyColormapAndFree(ClientPtr client)
{
Colormap mid;
ColormapPtr pSrcMap;
@ -2580,7 +2572,7 @@ ProcCopyColormapAndFree(register ClientPtr client)
}
int
ProcInstallColormap(register ClientPtr client)
ProcInstallColormap(ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xResourceReq);
@ -2601,7 +2593,7 @@ ProcInstallColormap(register ClientPtr client)
}
int
ProcUninstallColormap(register ClientPtr client)
ProcUninstallColormap(ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xResourceReq);
@ -2623,7 +2615,7 @@ ProcUninstallColormap(register ClientPtr client)
}
int
ProcListInstalledColormaps(register ClientPtr client)
ProcListInstalledColormaps(ClientPtr client)
{
xListInstalledColormapsReply *preply;
int nummaps, rc;
@ -2656,7 +2648,7 @@ ProcListInstalledColormaps(register ClientPtr client)
}
int
ProcAllocColor (register ClientPtr client)
ProcAllocColor (ClientPtr client)
{
ColormapPtr pmap;
int retval;
@ -2698,7 +2690,7 @@ ProcAllocColor (register ClientPtr client)
}
int
ProcAllocNamedColor (register ClientPtr client)
ProcAllocNamedColor (ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xAllocNamedColorReq);
@ -2750,7 +2742,7 @@ ProcAllocNamedColor (register ClientPtr client)
}
int
ProcAllocColorCells (register ClientPtr client)
ProcAllocColorCells (ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xAllocColorCellsReq);
@ -2816,7 +2808,7 @@ ProcAllocColorCells (register ClientPtr client)
}
int
ProcAllocColorPlanes(register ClientPtr client)
ProcAllocColorPlanes(ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xAllocColorPlanesReq);
@ -2880,7 +2872,7 @@ ProcAllocColorPlanes(register ClientPtr client)
}
int
ProcFreeColors(register ClientPtr client)
ProcFreeColors(ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xFreeColorsReq);
@ -2949,7 +2941,7 @@ ProcStoreColors (ClientPtr client)
}
int
ProcStoreNamedColor (register ClientPtr client)
ProcStoreNamedColor (ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xStoreNamedColorReq);
@ -2983,7 +2975,7 @@ ProcStoreNamedColor (register ClientPtr client)
}
int
ProcQueryColors(register ClientPtr client)
ProcQueryColors(ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xQueryColorsReq);
@ -3034,7 +3026,7 @@ ProcQueryColors(register ClientPtr client)
}
int
ProcLookupColor(register ClientPtr client)
ProcLookupColor(ClientPtr client)
{
ColormapPtr pcmp;
REQUEST(xLookupColorReq);
@ -3072,17 +3064,16 @@ ProcLookupColor(register ClientPtr client)
}
int
ProcCreateCursor (register ClientPtr client)
ProcCreateCursor (ClientPtr client)
{
CursorPtr pCursor;
register PixmapPtr src;
register PixmapPtr msk;
CursorPtr pCursor;
PixmapPtr src;
PixmapPtr msk;
unsigned char * srcbits;
unsigned char * mskbits;
unsigned short width, height;
long n;
CursorMetricRec cm;
CursorMetricRec cm;
REQUEST(xCreateCursorReq);
@ -3137,7 +3128,7 @@ ProcCreateCursor (register ClientPtr client)
XYPixmap, 1, (pointer)srcbits);
if ( msk == (PixmapPtr)NULL)
{
register unsigned char *bits = mskbits;
unsigned char *bits = mskbits;
while (--n >= 0)
*bits++ = ~0;
}
@ -3162,7 +3153,7 @@ ProcCreateCursor (register ClientPtr client)
}
int
ProcCreateGlyphCursor (register ClientPtr client)
ProcCreateGlyphCursor (ClientPtr client)
{
CursorPtr pCursor;
int res;
@ -3186,7 +3177,7 @@ ProcCreateGlyphCursor (register ClientPtr client)
int
ProcFreeCursor (register ClientPtr client)
ProcFreeCursor (ClientPtr client)
{
CursorPtr pCursor;
REQUEST(xResourceReq);
@ -3207,7 +3198,7 @@ ProcFreeCursor (register ClientPtr client)
}
int
ProcQueryBestSize (register ClientPtr client)
ProcQueryBestSize (ClientPtr client)
{
xQueryBestSizeReply reply;
DrawablePtr pDraw;
@ -3244,7 +3235,7 @@ ProcQueryBestSize (register ClientPtr client)
int
ProcSetScreenSaver (register ClientPtr client)
ProcSetScreenSaver (ClientPtr client)
{
int blankingOption, exposureOption;
REQUEST(xSetScreenSaverReq);
@ -3300,7 +3291,7 @@ ProcSetScreenSaver (register ClientPtr client)
}
int
ProcGetScreenSaver(register ClientPtr client)
ProcGetScreenSaver(ClientPtr client)
{
xGetScreenSaverReply rep;
@ -3317,7 +3308,7 @@ ProcGetScreenSaver(register ClientPtr client)
}
int
ProcChangeHosts(register ClientPtr client)
ProcChangeHosts(ClientPtr client)
{
REQUEST(xChangeHostsReq);
int result;
@ -3341,7 +3332,7 @@ ProcChangeHosts(register ClientPtr client)
}
int
ProcListHosts(register ClientPtr client)
ProcListHosts(ClientPtr client)
{
xListHostsReply reply;
int len, nHosts, result;
@ -3372,7 +3363,7 @@ ProcListHosts(register ClientPtr client)
}
int
ProcChangeAccessControl(register ClientPtr client)
ProcChangeAccessControl(ClientPtr client)
{
int result;
REQUEST(xSetAccessControlReq);
@ -3389,8 +3380,30 @@ ProcChangeAccessControl(register ClientPtr client)
return (result);
}
/*********************
* CloseDownRetainedResources
*
* Find all clients that are gone and have terminated in RetainTemporary
* and destroy their resources.
*********************/
static void
CloseDownRetainedResources(void)
{
int i;
ClientPtr client;
for (i=1; i<currentMaxClients; i++)
{
client = clients[i];
if (client && (client->closeDownMode == RetainTemporary)
&& (client->clientGone))
CloseDownClient(client);
}
}
int
ProcKillClient(register ClientPtr client)
ProcKillClient(ClientPtr client)
{
REQUEST(xResourceReq);
ClientPtr killclient;
@ -3422,7 +3435,7 @@ ProcKillClient(register ClientPtr client)
}
int
ProcSetFontPath(register ClientPtr client)
ProcSetFontPath(ClientPtr client)
{
unsigned char *ptr;
unsigned long nbytes, total;
@ -3457,7 +3470,7 @@ ProcSetFontPath(register ClientPtr client)
}
int
ProcGetFontPath(register ClientPtr client)
ProcGetFontPath(ClientPtr client)
{
xGetFontPathReply reply;
int stringLens, numpaths;
@ -3479,7 +3492,7 @@ ProcGetFontPath(register ClientPtr client)
}
int
ProcChangeCloseDownMode(register ClientPtr client)
ProcChangeCloseDownMode(ClientPtr client)
{
REQUEST(xSetCloseDownModeReq);
@ -3498,7 +3511,7 @@ ProcChangeCloseDownMode(register ClientPtr client)
}
}
int ProcForceScreenSaver(register ClientPtr client)
int ProcForceScreenSaver(ClientPtr client)
{
REQUEST(xForceScreenSaverReq);
@ -3514,7 +3527,7 @@ int ProcForceScreenSaver(register ClientPtr client)
return client->noClientException;
}
int ProcNoOperation(register ClientPtr client)
int ProcNoOperation(ClientPtr client)
{
REQUEST_AT_LEAST_SIZE(xReq);
@ -3557,7 +3570,7 @@ InitProcVectors(void)
char dispatchExceptionAtReset = DE_RESET;
void
CloseDownClient(register ClientPtr client)
CloseDownClient(ClientPtr client)
{
Bool really_close_down = client->clientGone ||
client->closeDownMode == DestroyAll;
@ -3657,28 +3670,6 @@ KillAllClients()
}
}
/*********************
* CloseDownRetainedResources
*
* Find all clients that are gone and have terminated in RetainTemporary
* and destroy their resources.
*********************/
void
CloseDownRetainedResources()
{
register int i;
register ClientPtr client;
for (i=1; i<currentMaxClients; i++)
{
client = clients[i];
if (client && (client->closeDownMode == RetainTemporary)
&& (client->clientGone))
CloseDownClient(client);
}
}
extern int clientPrivateLen;
extern unsigned *clientPrivateSizes;
extern unsigned totalClientSize;
@ -3738,11 +3729,11 @@ void InitClient(ClientPtr client, int i, pointer ospriv)
int
InitClientPrivates(ClientPtr client)
{
register char *ptr;
char *ptr;
DevUnion *ppriv;
register unsigned *sizes;
register unsigned size;
register int i;
unsigned *sizes;
unsigned size;
int i;
if (totalClientSize == sizeof(ClientRec))
ppriv = (DevUnion *)NULL;
@ -3792,8 +3783,8 @@ InitClientPrivates(ClientPtr client)
ClientPtr NextAvailableClient(pointer ospriv)
{
register int i;
register ClientPtr client;
int i;
ClientPtr client;
xReq data;
i = nextFreeClientID;
@ -3834,10 +3825,10 @@ ClientPtr NextAvailableClient(pointer ospriv)
}
int
ProcInitialConnection(register ClientPtr client)
ProcInitialConnection(ClientPtr client)
{
REQUEST(xReq);
register xConnClientPrefix *prefix;
xConnClientPrefix *prefix;
int whichbyte = 1;
prefix = (xConnClientPrefix *)((char *)stuff + sz_xReq);
@ -3861,10 +3852,10 @@ ProcInitialConnection(register ClientPtr client)
}
int
SendConnSetup(register ClientPtr client, char *reason)
SendConnSetup(ClientPtr client, char *reason)
{
register xWindowRoot *root;
register int i;
xWindowRoot *root;
int i;
int numScreens;
char* lConnectionInfo;
xConnSetupPrefix* lconnSetupPrefix;
@ -3919,8 +3910,8 @@ SendConnSetup(register ClientPtr client, char *reason)
for (i=0; i<numScreens; i++)
{
register unsigned int j;
register xDepth *pDepth;
unsigned int j;
xDepth *pDepth;
root->currentInputMask = WindowTable[i]->eventMask |
wOtherEventMasks (WindowTable[i]);
@ -3961,10 +3952,10 @@ SendConnSetup(register ClientPtr client, char *reason)
}
int
ProcEstablishConnection(register ClientPtr client)
ProcEstablishConnection(ClientPtr client)
{
char *reason, *auth_proto, *auth_string;
register xConnClientPrefix *prefix;
xConnClientPrefix *prefix;
REQUEST(xReq);
prefix = (xConnClientPrefix *)((char *)stuff + sz_xReq);
@ -4013,7 +4004,7 @@ SendErrorToClient(ClientPtr client, unsigned majorCode, unsigned minorCode,
void
DeleteWindowFromAnySelections(WindowPtr pWin)
{
register int i;
int i;
for (i = 0; i< NumCurrentSelections; i++)
if (CurrentSelections[i].pWin == pWin)
@ -4037,7 +4028,7 @@ DeleteWindowFromAnySelections(WindowPtr pWin)
static void
DeleteClientFromAnySelections(ClientPtr client)
{
register int i;
int i;
for (i = 0; i< NumCurrentSelections; i++)
if (CurrentSelections[i].client == client)

6
dix/dixfonts.c
View File

@ -1145,9 +1145,9 @@ static XID clearGC[] = { CT_NONE };
#define clearGCmask (GCClipMask)
int
doPolyText(ClientPtr client, register PTclosurePtr c)
doPolyText(ClientPtr client, PTclosurePtr c)
{
register FontPtr pFont = c->pGC->font, oldpFont;
FontPtr pFont = c->pGC->font, oldpFont;
Font fid, oldfid;
int err = Success, lgerr; /* err is in X error, not font error, space */
enum { NEVER_SLEPT, START_SLEEP, SLEEPING } client_state = NEVER_SLEPT;
@ -1447,7 +1447,7 @@ PolyText(ClientPtr client, DrawablePtr pDraw, GC *pGC, unsigned char *pElt,
#undef FontShiftSize
int
doImageText(ClientPtr client, register ITclosurePtr c)
doImageText(ClientPtr client, ITclosurePtr c)
{
int err = Success, lgerr; /* err is in X error, not font error, space */
FontPathElementPtr fpe;

16
dix/dixutils.c
View File

@ -168,7 +168,7 @@ ISOLatin1ToLower (unsigned char source)
_X_EXPORT void
CopyISOLatin1Lowered(unsigned char *dest, unsigned char *source, int length)
{
register int i;
int i;
for (i = 0; i < length; i++, source++, dest++)
*dest = ISOLatin1ToLower (*source);
@ -392,8 +392,8 @@ AlterSaveSetForClient(ClientPtr client, WindowPtr pWin, unsigned mode,
void
DeleteWindowFromAnySaveSet(WindowPtr pWin)
{
register int i;
register ClientPtr client;
int i;
ClientPtr client;
for (i = 0; i< currentMaxClients; i++)
{
@ -434,7 +434,7 @@ static Bool handlerDeleted;
void
BlockHandler(pointer pTimeout, pointer pReadmask)
{
register int i, j;
int i, j;
++inHandler;
for (i = 0; i < screenInfo.numScreens; i++)
@ -468,7 +468,7 @@ BlockHandler(pointer pTimeout, pointer pReadmask)
void
WakeupHandler(int result, pointer pReadmask)
{
register int i, j;
int i, j;
++inHandler;
for (i = numHandlers - 1; i >= 0; i--)
@ -882,9 +882,7 @@ static CallbackFuncsRec default_cbfuncs =
_DeleteCallbackList
};
/* ===== Public Procedures ===== */
Bool
static Bool
CreateCallbackList(CallbackListPtr *pcbl, CallbackFuncsPtr cbfuncs)
{
CallbackListPtr cbl;
@ -916,6 +914,8 @@ CreateCallbackList(CallbackListPtr *pcbl, CallbackFuncsPtr cbfuncs)
return TRUE;
}
/* ===== Public Procedures ===== */
_X_EXPORT Bool
AddCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, pointer data)
{

192
dix/events.c
View File

@ -133,7 +133,7 @@ of the copyright holder.
#ifdef XKB
#include <X11/extensions/XKBproto.h>
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
extern Bool XkbFilterEvents(ClientPtr, int, xEvent *);
#endif
@ -156,7 +156,7 @@ extern Mask xevieFilters[128];
extern int xevieEventSent;
extern int xevieKBEventSent;
int xeviegrabState = 0;
xEvent *xeviexE;
static xEvent *xeviexE;
#endif
#include <X11/extensions/XIproto.h>
@ -761,8 +761,8 @@ CheckPhysLimits(
static void
CheckVirtualMotion(
register QdEventPtr qe,
register WindowPtr pWin)
QdEventPtr qe,
WindowPtr pWin)
{
#ifdef PANORAMIX
if(!noPanoramiXExtension) {
@ -875,7 +875,7 @@ ChangeToCursor(CursorPtr cursor)
/* returns true if b is a descendent of a */
Bool
IsParent(register WindowPtr a, register WindowPtr b)
IsParent(WindowPtr a, WindowPtr b)
{
for (b = b->parent; b; b = b->parent)
if (b == a) return TRUE;
@ -885,8 +885,8 @@ IsParent(register WindowPtr a, register WindowPtr b)
static void
PostNewCursor(void)
{
register WindowPtr win;
register GrabPtr grab = inputInfo.pointer->grab;
WindowPtr win;
GrabPtr grab = inputInfo.pointer->grab;
if (syncEvents.playingEvents)
return;
@ -952,7 +952,7 @@ XineramaGetCursorScreen()
#define TIMESLOP (5 * 60 * 1000) /* 5 minutes */
static void
MonthChangedOrBadTime(register xEvent *xE)
MonthChangedOrBadTime(xEvent *xE)
{
/* If the ddx/OS is careless about not processing timestamped events from
* different sources in sorted order, then it's possible for time to go
@ -971,7 +971,7 @@ MonthChangedOrBadTime(register xEvent *xE)
lastDeviceEventTime = currentTime; }
void
NoticeEventTime(register xEvent *xE)
NoticeEventTime(xEvent *xE)
{
if (!syncEvents.playingEvents)
NoticeTime(xE);
@ -984,8 +984,8 @@ NoticeEventTime(register xEvent *xE)
void
EnqueueEvent(xEvent *xE, DeviceIntPtr device, int count)
{
register QdEventPtr tail = *syncEvents.pendtail;
register QdEventPtr qe;
QdEventPtr tail = *syncEvents.pendtail;
QdEventPtr qe;
xEvent *qxE;
NoticeTime(xE);
@ -1059,8 +1059,8 @@ EnqueueEvent(xEvent *xE, DeviceIntPtr device, int count)
static void
PlayReleasedEvents(void)
{
register QdEventPtr *prev, qe;
register DeviceIntPtr dev;
QdEventPtr *prev, qe;
DeviceIntPtr dev;
prev = &syncEvents.pending;
while ( (qe = *prev) )
@ -1104,7 +1104,7 @@ PlayReleasedEvents(void)
}
static void
FreezeThaw(register DeviceIntPtr dev, Bool frozen)
FreezeThaw(DeviceIntPtr dev, Bool frozen)
{
dev->sync.frozen = frozen;
if (frozen)
@ -1116,13 +1116,13 @@ FreezeThaw(register DeviceIntPtr dev, Bool frozen)
void
ComputeFreezes()
{
register DeviceIntPtr replayDev = syncEvents.replayDev;
register int i;
DeviceIntPtr replayDev = syncEvents.replayDev;
int i;
WindowPtr w;
register xEvent *xE;
xEvent *xE;
int count;
GrabPtr grab;
register DeviceIntPtr dev;
DeviceIntPtr dev;
for (dev = inputInfo.devices; dev; dev = dev->next)
FreezeThaw(dev, dev->sync.other || (dev->sync.state >= FROZEN));
@ -1198,10 +1198,10 @@ ScreenRestructured (ScreenPtr pScreen)
#endif
void
CheckGrabForSyncs(register DeviceIntPtr thisDev, Bool thisMode, Bool otherMode)
CheckGrabForSyncs(DeviceIntPtr thisDev, Bool thisMode, Bool otherMode)
{
register GrabPtr grab = thisDev->grab;
register DeviceIntPtr dev;
GrabPtr grab = thisDev->grab;
DeviceIntPtr dev;
if (thisMode == GrabModeSync)
thisDev->sync.state = FROZEN_NO_EVENT;
@ -1232,7 +1232,7 @@ CheckGrabForSyncs(register DeviceIntPtr thisDev, Bool thisMode, Bool otherMode)
}
void
ActivatePointerGrab(register DeviceIntPtr mouse, register GrabPtr grab,
ActivatePointerGrab(DeviceIntPtr mouse, GrabPtr grab,
TimeStamp time, Bool autoGrab)
{
WindowPtr oldWin = (mouse->grab) ? mouse->grab->window
@ -1260,10 +1260,10 @@ ActivatePointerGrab(register DeviceIntPtr mouse, register GrabPtr grab,
}
void
DeactivatePointerGrab(register DeviceIntPtr mouse)
DeactivatePointerGrab(DeviceIntPtr mouse)
{
register GrabPtr grab = mouse->grab;
register DeviceIntPtr dev;
GrabPtr grab = mouse->grab;
DeviceIntPtr dev;
mouse->valuator->motionHintWindow = NullWindow;
mouse->grab = NullGrab;
@ -1284,7 +1284,7 @@ DeactivatePointerGrab(register DeviceIntPtr mouse)
}
void
ActivateKeyboardGrab(register DeviceIntPtr keybd, GrabPtr grab, TimeStamp time, Bool passive)
ActivateKeyboardGrab(DeviceIntPtr keybd, GrabPtr grab, TimeStamp time, Bool passive)
{
WindowPtr oldWin;
@ -1310,11 +1310,11 @@ ActivateKeyboardGrab(register DeviceIntPtr keybd, GrabPtr grab, TimeStamp time,
}
void
DeactivateKeyboardGrab(register DeviceIntPtr keybd)
DeactivateKeyboardGrab(DeviceIntPtr keybd)
{
register GrabPtr grab = keybd->grab;
register DeviceIntPtr dev;
register WindowPtr focusWin = keybd->focus ? keybd->focus->win
GrabPtr grab = keybd->grab;
DeviceIntPtr dev;
WindowPtr focusWin = keybd->focus ? keybd->focus->win
: sprite.win;
if (focusWin == FollowKeyboardWin)
@ -1338,7 +1338,7 @@ AllowSome(ClientPtr client, TimeStamp time, DeviceIntPtr thisDev, int newState)
{
Bool thisGrabbed, otherGrabbed, othersFrozen, thisSynced;
TimeStamp grabTime;
register DeviceIntPtr dev;
DeviceIntPtr dev;
thisGrabbed = thisDev->grab && SameClient(thisDev->grab, client);
thisSynced = FALSE;
@ -1442,7 +1442,7 @@ AllowSome(ClientPtr client, TimeStamp time, DeviceIntPtr thisDev, int newState)
}
int
ProcAllowEvents(register ClientPtr client)
ProcAllowEvents(ClientPtr client)
{
TimeStamp time;
DeviceIntPtr mouse = inputInfo.pointer;
@ -1487,7 +1487,7 @@ ProcAllowEvents(register ClientPtr client)
void
ReleaseActiveGrabs(ClientPtr client)
{
register DeviceIntPtr dev;
DeviceIntPtr dev;
Bool done;
/* XXX CloseDownClient should remove passive grabs before
@ -1589,12 +1589,12 @@ TryClientEvents (ClientPtr client, xEvent *pEvents, int count, Mask mask,
}
int
DeliverEventsToWindow(register WindowPtr pWin, xEvent *pEvents, int count,
DeliverEventsToWindow(WindowPtr pWin, xEvent *pEvents, int count,
Mask filter, GrabPtr grab, int mskidx)
{
int deliveries = 0, nondeliveries = 0;
int attempt;
register InputClients *other;
InputClients *other;
ClientPtr client = NullClient;
Mask deliveryMask = 0; /* If a grab occurs due to a button press, then
this mask is the mask of the grab. */
@ -1708,10 +1708,10 @@ XineramaTryClientEventsResult(
#endif
int
MaybeDeliverEventsToClient(register WindowPtr pWin, xEvent *pEvents,
MaybeDeliverEventsToClient(WindowPtr pWin, xEvent *pEvents,
int count, Mask filter, ClientPtr dontClient)
{
register OtherClients *other;
OtherClients *other;
if (pWin->eventMask & filter)
@ -1799,8 +1799,8 @@ FixUpEventFromWindow(
}
int
DeliverDeviceEvents(register WindowPtr pWin, register xEvent *xE, GrabPtr grab,
register WindowPtr stopAt, DeviceIntPtr dev, int count)
DeliverDeviceEvents(WindowPtr pWin, xEvent *xE, GrabPtr grab,
WindowPtr stopAt, DeviceIntPtr dev, int count)
{
Window child = None;
int type = xE->u.u.type;
@ -1809,7 +1809,7 @@ DeliverDeviceEvents(register WindowPtr pWin, register xEvent *xE, GrabPtr grab,
if (type & EXTENSION_EVENT_BASE)
{
register OtherInputMasks *inputMasks;
OtherInputMasks *inputMasks;
int mskidx = dev->id;
inputMasks = wOtherInputMasks(pWin);
@ -1863,8 +1863,8 @@ DeliverDeviceEvents(register WindowPtr pWin, register xEvent *xE, GrabPtr grab,
/* not useful for events that propagate up the tree or extension events */
_X_EXPORT int
DeliverEvents(register WindowPtr pWin, register xEvent *xE, int count,
register WindowPtr otherParent)
DeliverEvents(WindowPtr pWin, xEvent *xE, int count,
WindowPtr otherParent)
{
Mask filter;
int deliveries;
@ -1929,7 +1929,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y)
static WindowPtr
XYToWindow(int x, int y)
{
register WindowPtr pWin;
WindowPtr pWin;
BoxRec box;
spriteTraceGood = 1; /* root window still there */
@ -2092,9 +2092,9 @@ void ReinitializeRootWindow(WindowPtr win, int xoff, int yoff)
#endif
void
DefineInitialRootWindow(register WindowPtr win)
DefineInitialRootWindow(WindowPtr win)
{
register ScreenPtr pScreen = win->drawable.pScreen;
ScreenPtr pScreen = win->drawable.pScreen;
sprite.hotPhys.pScreen = pScreen;
sprite.hotPhys.x = pScreen->width / 2;
@ -2411,13 +2411,13 @@ BorderSizeNotEmpty(WindowPtr pWin)
static Bool
CheckPassiveGrabsOnWindow(
WindowPtr pWin,
register DeviceIntPtr device,
register xEvent *xE,
DeviceIntPtr device,
xEvent *xE,
int count)
{
register GrabPtr grab = wPassiveGrabs(pWin);
GrabPtr grab = wPassiveGrabs(pWin);
GrabRec tempGrab;
register xEvent *dxE;
xEvent *dxE;
if (!grab)
return FALSE;
@ -2513,12 +2513,12 @@ tried. PRH
*/
Bool
CheckDeviceGrabs(register DeviceIntPtr device, register xEvent *xE,
CheckDeviceGrabs(DeviceIntPtr device, xEvent *xE,
int checkFirst, int count)
{
register int i;
register WindowPtr pWin = NULL;
register FocusClassPtr focus = device->focus;
int i;
WindowPtr pWin = NULL;
FocusClassPtr focus = device->focus;
if (((xE->u.u.type == ButtonPress)
#if defined(XINPUT) && defined(XKB)
@ -2585,13 +2585,13 @@ DeliverFocusedEvent(DeviceIntPtr keybd, xEvent *xE, WindowPtr window, int count)
}
void
DeliverGrabbedEvent(register xEvent *xE, register DeviceIntPtr thisDev,
DeliverGrabbedEvent(xEvent *xE, DeviceIntPtr thisDev,
Bool deactivateGrab, int count)
{
register GrabPtr grab = thisDev->grab;
GrabPtr grab = thisDev->grab;
int deliveries = 0;
register DeviceIntPtr dev;
register xEvent *dxE;
DeviceIntPtr dev;
xEvent *dxE;
if (grab->ownerEvents)
{
@ -2668,19 +2668,19 @@ DeliverGrabbedEvent(register xEvent *xE, register DeviceIntPtr thisDev,
void
#ifdef XKB
CoreProcessKeyboardEvent (register xEvent *xE, register DeviceIntPtr keybd, int count)
CoreProcessKeyboardEvent (xEvent *xE, DeviceIntPtr keybd, int count)
#else
ProcessKeyboardEvent (register xEvent *xE, register DeviceIntPtr keybd, int count)
ProcessKeyboardEvent (xEvent *xE, DeviceIntPtr keybd, int count)
#endif
{
int key, bit;
register BYTE *kptr;
register int i;
register CARD8 modifiers;
register CARD16 mask;
BYTE *kptr;
int i;
CARD8 modifiers;
CARD16 mask;
GrabPtr grab = keybd->grab;
Bool deactivateGrab = FALSE;
register KeyClassPtr keyc = keybd->key;
KeyClassPtr keyc = keybd->key;
#ifdef XEVIE
static Window rootWin = 0;
@ -2832,11 +2832,11 @@ drawable.id:0;
CoreProcessKeyEvent to be called, as in for example Mouse Keys.
*/
void
FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
FixKeyState (xEvent *xE, DeviceIntPtr keybd)
{
int key, bit;
register BYTE *kptr;
register KeyClassPtr keyc = keybd->key;
BYTE *kptr;
KeyClassPtr keyc = keybd->key;
key = xE->u.u.detail;
kptr = &keyc->down[key >> 3];
@ -2863,14 +2863,14 @@ FixKeyState (register xEvent *xE, register DeviceIntPtr keybd)
void
#ifdef XKB
CoreProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count)
CoreProcessPointerEvent (xEvent *xE, DeviceIntPtr mouse, int count)
#else
ProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count)
ProcessPointerEvent (xEvent *xE, DeviceIntPtr mouse, int count)
#endif
{
register GrabPtr grab = mouse->grab;
GrabPtr grab = mouse->grab;
Bool deactivateGrab = FALSE;
register ButtonClassPtr butc = mouse->button;
ButtonClassPtr butc = mouse->button;
#ifdef XKB
XkbSrvInfoPtr xkbi= inputInfo.keyboard->key->xkbInfo;
#endif
@ -2914,8 +2914,8 @@ ProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count
}
if (xE->u.u.type != MotionNotify)
{
register int key;
register BYTE *kptr;
int key;
BYTE *kptr;
int bit;
XE_KBPTR.rootX = sprite.hot.x;
@ -2976,10 +2976,10 @@ ProcessPointerEvent (register xEvent *xE, register DeviceIntPtr mouse, int count
void
RecalculateDeliverableEvents(pWin)
register WindowPtr pWin;
WindowPtr pWin;
{
register OtherClients *others;
register WindowPtr pChild;
OtherClients *others;
WindowPtr pChild;
pChild = pWin;
while (1)
@ -3018,8 +3018,8 @@ RecalculateDeliverableEvents(pWin)
int
OtherClientGone(pointer value, XID id)
{
register OtherClientsPtr other, prev;
register WindowPtr pWin = (WindowPtr)value;
OtherClientsPtr other, prev;
WindowPtr pWin = (WindowPtr)value;
prev = 0;
for (other = wOtherClients(pWin); other; other = other->next)
@ -3045,7 +3045,7 @@ OtherClientGone(pointer value, XID id)
}
int
EventSelectForWindow(register WindowPtr pWin, register ClientPtr client, Mask mask)
EventSelectForWindow(WindowPtr pWin, ClientPtr client, Mask mask)
{
Mask check;
OtherClients * others;
@ -3117,10 +3117,10 @@ maskSet:
}
int
EventSuppressForWindow(register WindowPtr pWin, register ClientPtr client,
EventSuppressForWindow(WindowPtr pWin, ClientPtr client,
Mask mask, Bool *checkOptional)
{
register int i, free;
int i, free;
if (mask & ~PropagateMask)
{
@ -3174,8 +3174,8 @@ EventSuppressForWindow(register WindowPtr pWin, register ClientPtr client,
static WindowPtr
CommonAncestor(
register WindowPtr a,
register WindowPtr b)
WindowPtr a,
WindowPtr b)
{
for (b = b->parent; b; b = b->parent)
if (IsParent(b, a)) return b;
@ -3187,14 +3187,14 @@ EnterLeaveEvent(
int type,
int mode,
int detail,
register WindowPtr pWin,
WindowPtr pWin,
Window child)
{
xEvent event;
register DeviceIntPtr keybd = inputInfo.keyboard;
DeviceIntPtr keybd = inputInfo.keyboard;
WindowPtr focus;
register DeviceIntPtr mouse = inputInfo.pointer;
register GrabPtr grab = mouse->grab;
DeviceIntPtr mouse = inputInfo.pointer;
GrabPtr grab = mouse->grab;
Mask mask;
if ((pWin == mouse->valuator->motionHintWindow) &&
@ -3278,7 +3278,7 @@ EnterNotifies(WindowPtr ancestor, WindowPtr child, int mode, int detail)
static void
LeaveNotifies(WindowPtr child, WindowPtr ancestor, int mode, int detail)
{
register WindowPtr pWin;
WindowPtr pWin;
if (ancestor == child)
return;
@ -3318,7 +3318,7 @@ DoEnterLeaveEvents(WindowPtr fromWin, WindowPtr toWin, int mode)
}
static void
FocusEvent(DeviceIntPtr dev, int type, int mode, int detail, register WindowPtr pWin)
FocusEvent(DeviceIntPtr dev, int type, int mode, int detail, WindowPtr pWin)
{
xEvent event;
@ -3388,7 +3388,7 @@ FocusOutEvents(
int mode, int detail,
Bool doAncestor)
{
register WindowPtr pWin;
WindowPtr pWin;
for (pWin = child; pWin != ancestor; pWin = pWin->parent)
FocusEvent(dev, FocusOut, mode, detail, pWin);
@ -3531,7 +3531,7 @@ SetInputFocus(
Time ctime,
Bool followOK)
{
register FocusClassPtr focus;
FocusClassPtr focus;
WindowPtr focusWin;
int mode, rc;
TimeStamp time;
@ -3579,7 +3579,7 @@ SetInputFocus(
else
{
int depth = 0;
register WindowPtr pWin;
WindowPtr pWin;
for (pWin = focusWin; pWin; pWin = pWin->parent) depth++;
if (depth > focus->traceSize)
@ -3745,7 +3745,7 @@ int
ProcChangeActivePointerGrab(ClientPtr client)
{
DeviceIntPtr device = inputInfo.pointer;
register GrabPtr grab = device->grab;
GrabPtr grab = device->grab;
CursorPtr newCursor, oldCursor;
REQUEST(xChangeActivePointerGrabReq);
TimeStamp time;
@ -3807,12 +3807,12 @@ ProcUngrabPointer(ClientPtr client)
}
int
GrabDevice(register ClientPtr client, register DeviceIntPtr dev,
GrabDevice(ClientPtr client, DeviceIntPtr dev,
unsigned this_mode, unsigned other_mode, Window grabWindow,
unsigned ownerEvents, Time ctime, Mask mask, CARD8 *status)
{
WindowPtr pWin;
register GrabPtr grab;
GrabPtr grab;
TimeStamp time;
int rc;
@ -4433,7 +4433,7 @@ CheckCursorConfinement(WindowPtr pWin)
Mask
EventMaskForClient(WindowPtr pWin, ClientPtr client)
{
register OtherClientsPtr other;
OtherClientsPtr other;
if (wClient (pWin) == client)
return pWin->eventMask;

95
dix/extension.c
View File

@ -66,8 +66,6 @@ SOFTWARE.
#define LAST_EVENT 128
#define LAST_ERROR 255
ScreenProcEntry AuxillaryScreenProcs[MAXSCREENS];
static ExtensionEntry **extensions = (ExtensionEntry **)NULL;
int lastEvent = EXTENSION_EVENT_BASE;
@ -81,11 +79,11 @@ extern unsigned totalExtensionSize;
static void
InitExtensionPrivates(ExtensionEntry *ext)
{
register char *ptr;
char *ptr;
DevUnion *ppriv;
register unsigned *sizes;
register unsigned size;
register int i;
unsigned *sizes;
unsigned size;
int i;
if (totalExtensionSize == sizeof(ExtensionEntry))
ppriv = (DevUnion *)NULL;
@ -115,7 +113,7 @@ AddExtension(char *name, int NumEvents, int NumErrors,
unsigned short (*MinorOpcodeProc)(ClientPtr c3))
{
int i;
register ExtensionEntry *ext, **newexts;
ExtensionEntry *ext, **newexts;
if (!MainProc || !SwappedMainProc || !CloseDownProc || !MinorOpcodeProc)
return((ExtensionEntry *) NULL);
@ -282,7 +280,7 @@ MinorOpcodeOfRequest(ClientPtr client)
void
CloseDownExtensions()
{
register int i,j;
int i,j;
for (i = NumExtensions - 1; i >= 0; i--)
{
@ -298,21 +296,8 @@ CloseDownExtensions()
extensions = (ExtensionEntry **)NULL;
lastEvent = EXTENSION_EVENT_BASE;
lastError = FirstExtensionError;
for (i=0; i<MAXSCREENS; i++)
{
register ScreenProcEntry *spentry = &AuxillaryScreenProcs[i];
while (spentry->num)
{
spentry->num--;
xfree(spentry->procList[spentry->num].name);
}
xfree(spentry->procList);
spentry->procList = (ProcEntryPtr)NULL;
}
}
int
ProcQueryExtension(ClientPtr client)
{
@ -363,7 +348,7 @@ ProcListExtensions(ClientPtr client)
if ( NumExtensions )
{
register int i, j;
int i, j;
for (i=0; i<NumExtensions; i++)
{
@ -406,72 +391,6 @@ ProcListExtensions(ClientPtr client)
return(client->noClientException);
}
ExtensionLookupProc
LookupProc(char *name, GCPtr pGC)
{
register int i;
register ScreenProcEntry *spentry;
spentry = &AuxillaryScreenProcs[pGC->pScreen->myNum];
if (spentry->num)
{
for (i = 0; i < spentry->num; i++)
if (strcmp(name, spentry->procList[i].name) == 0)
return(spentry->procList[i].proc);
}
return (ExtensionLookupProc)NULL;
}
Bool
RegisterProc(char *name, GC *pGC, ExtensionLookupProc proc)
{
return RegisterScreenProc(name, pGC->pScreen, proc);
}
Bool
RegisterScreenProc(char *name, ScreenPtr pScreen, ExtensionLookupProc proc)
{
register ScreenProcEntry *spentry;
register ProcEntryPtr procEntry = (ProcEntryPtr)NULL;
char *newname;
int i;
spentry = &AuxillaryScreenProcs[pScreen->myNum];
/* first replace duplicates */
if (spentry->num)
{
for (i = 0; i < spentry->num; i++)
if (strcmp(name, spentry->procList[i].name) == 0)
{
procEntry = &spentry->procList[i];
break;
}
}
if (procEntry)
procEntry->proc = proc;
else
{
newname = (char *)xalloc(strlen(name)+1);
if (!newname)
return FALSE;
procEntry = (ProcEntryPtr)
xrealloc(spentry->procList,
sizeof(ProcEntryRec) * (spentry->num+1));
if (!procEntry)
{
xfree(newname);
return FALSE;
}
spentry->procList = procEntry;
procEntry += spentry->num;
procEntry->name = newname;
strcpy(newname, name);
procEntry->proc = proc;
spentry->num++;
}
return TRUE;
}
#ifdef XSERVER_DTRACE
void LoadExtensionNames(char **RequestNames) {
int i;

81
dix/gc.c
View File

@ -69,7 +69,7 @@ extern FontPtr defaultFont;
static Bool CreateDefaultTile(GCPtr pGC);
unsigned char DefaultDash[2] = {4, 4};
static unsigned char DefaultDash[2] = {4, 4};
_X_EXPORT void
ValidateGC(DrawablePtr pDraw, GC *pGC)
@ -144,12 +144,12 @@ ValidateGC(DrawablePtr pDraw, GC *pGC)
assert(pUnion); _var = (_type)pUnion->ptr; pUnion++; }
_X_EXPORT int
dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC32, ChangeGCValPtr pUnion)
dixChangeGC(ClientPtr client, GC *pGC, BITS32 mask, CARD32 *pC32, ChangeGCValPtr pUnion)
{
register BITS32 index2;
register int error = 0;
PixmapPtr pPixmap;
BITS32 maskQ;
BITS32 index2;
int error = 0;
PixmapPtr pPixmap;
BITS32 maskQ;
assert( (pC32 && !pUnion) || (!pC32 && pUnion) );
pGC->serialNumber |= GC_CHANGE_SERIAL_BIT;
@ -522,7 +522,7 @@ dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC
/* Publically defined entry to ChangeGC. Just calls dixChangeGC and tells
* it that all of the entries are constants or IDs */
_X_EXPORT int
ChangeGC(register GC *pGC, register BITS32 mask, XID *pval)
ChangeGC(GC *pGC, BITS32 mask, XID *pval)
{
return (dixChangeGC(NullClient, pGC, mask, pval, NULL));
}
@ -548,7 +548,7 @@ NOTE:
32 bits long
*/
_X_EXPORT int
DoChangeGC(register GC *pGC, register BITS32 mask, XID *pval, int fPointer)
DoChangeGC(GC *pGC, BITS32 mask, XID *pval, int fPointer)
{
if (fPointer)
/* XXX might be a problem on 64 bit big-endian servers */
@ -572,11 +572,11 @@ static GCPtr
AllocateGC(ScreenPtr pScreen)
{
GCPtr pGC;
register char *ptr;
register DevUnion *ppriv;
register unsigned *sizes;
register unsigned size;
register int i;
char *ptr;
DevUnion *ppriv;
unsigned *sizes;
unsigned size;
int i;
pGC = (GCPtr)xalloc(pScreen->totalGCSize);
if (pGC)
@ -602,7 +602,7 @@ AllocateGC(ScreenPtr pScreen)
_X_EXPORT GCPtr
CreateGC(DrawablePtr pDrawable, BITS32 mask, XID *pval, int *pStatus)
{
register GCPtr pGC;
GCPtr pGC;
pGC = AllocateGC(pDrawable->pScreen);
if (!pGC)
@ -724,11 +724,11 @@ CreateDefaultTile (GCPtr pGC)
}
_X_EXPORT int
CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
CopyGC(GC *pgcSrc, GC *pgcDst, BITS32 mask)
{
register BITS32 index2;
BITS32 maskQ;
int error = 0;
BITS32 index2;
BITS32 maskQ;
int error = 0;
if (pgcSrc == pgcDst)
return Success;
@ -907,17 +907,6 @@ FreeGC(pointer value, XID gid)
return(Success);
}
void
SetGCMask(GCPtr pGC, Mask selectMask, Mask newDataMask)
{
pGC->stateChanges = (~selectMask & pGC->stateChanges) |
(selectMask & newDataMask);
if (selectMask & newDataMask)
pGC->serialNumber |= GC_CHANGE_SERIAL_BIT;
}
/* CreateScratchGC(pScreen, depth)
like CreateGC, but doesn't do the default tile or stipple,
since we can't create them without already having a GC. any code
@ -934,7 +923,7 @@ go with CreateGC() or ChangeGC().)
_X_EXPORT GCPtr
CreateScratchGC(ScreenPtr pScreen, unsigned depth)
{
register GCPtr pGC;
GCPtr pGC;
pGC = AllocateGC(pScreen);
if (!pGC)
@ -986,8 +975,8 @@ CreateScratchGC(ScreenPtr pScreen, unsigned depth)
void
FreeGCperDepth(int screenNum)
{
register int i;
register ScreenPtr pScreen;
int i;
ScreenPtr pScreen;
GCPtr *ppGC;
pScreen = screenInfo.screens[screenNum];
@ -1002,8 +991,8 @@ FreeGCperDepth(int screenNum)
Bool
CreateGCperDepth(int screenNum)
{
register int i;
register ScreenPtr pScreen;
int i;
ScreenPtr pScreen;
DepthPtr pDepth;
GCPtr *ppGC;
@ -1035,7 +1024,7 @@ CreateGCperDepth(int screenNum)
Bool
CreateDefaultStipple(int screenNum)
{
register ScreenPtr pScreen;
ScreenPtr pScreen;
XID tmpval[3];
xRectangle rect;
CARD16 w, h;
@ -1077,10 +1066,10 @@ FreeDefaultStipple(int screenNum)
}
_X_EXPORT int
SetDashes(register GCPtr pGC, unsigned offset, unsigned ndash, unsigned char *pdash)
SetDashes(GCPtr pGC, unsigned offset, unsigned ndash, unsigned char *pdash)
{
register long i;
register unsigned char *p, *indash;
long i;
unsigned char *p, *indash;
BITS32 maskQ = 0;
i = ndash;
@ -1135,8 +1124,8 @@ SetDashes(register GCPtr pGC, unsigned offset, unsigned ndash, unsigned char *pd
_X_EXPORT int
VerifyRectOrder(int nrects, xRectangle *prects, int ordering)
{
register xRectangle *prectP, *prectN;
register int i;
xRectangle *prectP, *prectN;
int i;
switch(ordering)
{
@ -1220,10 +1209,10 @@ SetClipRects(GCPtr pGC, int xOrigin, int yOrigin, int nrects,
you use it often enough it will become real.)
*/
_X_EXPORT GCPtr
GetScratchGC(register unsigned depth, register ScreenPtr pScreen)
GetScratchGC(unsigned depth, ScreenPtr pScreen)
{
register int i;
register GCPtr pGC;
int i;
GCPtr pGC;
for (i=0; i<=pScreen->numDepths; i++)
if ( pScreen->GCperDepth[i]->depth == depth &&
@ -1269,10 +1258,10 @@ mark it as available.
if not, free it for real
*/
_X_EXPORT void
FreeScratchGC(register GCPtr pGC)
FreeScratchGC(GCPtr pGC)
{
register ScreenPtr pScreen = pGC->pScreen;
register int i;
ScreenPtr pScreen = pGC->pScreen;
int i;
for (i=0; i<=pScreen->numDepths; i++)
{

2
dix/getevents.c
View File

@ -44,7 +44,7 @@
#ifdef XKB
#include <X11/extensions/XKBproto.h>
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
extern Bool XkbCopyKeymap(XkbDescPtr src, XkbDescPtr dst, Bool sendNotifies);
#endif

8
dix/glyphcurs.c
View File

@ -74,10 +74,10 @@ cursor metrics.
*/
int
ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, unsigned char **ppbits)
ServerBitsFromGlyph(FontPtr pfont, unsigned ch, CursorMetricPtr cm, unsigned char **ppbits)
{
register ScreenPtr pScreen;
register GCPtr pGC;
ScreenPtr pScreen;
GCPtr pGC;
xRectangle rect;
PixmapPtr ppix;
long nby;
@ -140,7 +140,7 @@ ServerBitsFromGlyph(FontPtr pfont, unsigned ch, register CursorMetricPtr cm, uns
Bool
CursorMetricsFromGlyph(register FontPtr pfont, unsigned ch, register CursorMetricPtr cm)
CursorMetricsFromGlyph(FontPtr pfont, unsigned ch, CursorMetricPtr cm)
{
CharInfoPtr pci;
unsigned long nglyphs;

8
dix/grabs.c
View File

@ -128,7 +128,7 @@ FreeGrab(GrabPtr pGrab)
int
DeletePassiveGrab(pointer value, XID id)
{
register GrabPtr g, prev;
GrabPtr g, prev;
GrabPtr pGrab = (GrabPtr)value;
/* it is OK if the grab isn't found */
@ -153,8 +153,8 @@ DeletePassiveGrab(pointer value, XID id)
static Mask *
DeleteDetailFromMask(Mask *pDetailMask, unsigned short detail)
{
register Mask *mask;
register int i;
Mask *mask;
int i;
mask = (Mask *)xalloc(sizeof(Mask) * MasksPerDetailMask);
if (mask)
@ -305,7 +305,7 @@ AddPassiveGrabToList(GrabPtr pGrab)
Bool
DeletePassiveGrabFromList(GrabPtr pMinuendGrab)
{
register GrabPtr grab;
GrabPtr grab;
GrabPtr *deletes, *adds;
Mask ***updates, **details;
int i, ndels, nadds, nups;

6
dix/privates.c
View File

@ -464,7 +464,7 @@ AllocateWindowPrivateIndex()
}
_X_EXPORT Bool
AllocateWindowPrivate(register ScreenPtr pScreen, int index2, unsigned amount)
AllocateWindowPrivate(ScreenPtr pScreen, int index2, unsigned amount)
{
unsigned oldamount;
@ -514,7 +514,7 @@ AllocateGCPrivateIndex()
}
_X_EXPORT Bool
AllocateGCPrivate(register ScreenPtr pScreen, int index2, unsigned amount)
AllocateGCPrivate(ScreenPtr pScreen, int index2, unsigned amount)
{
unsigned oldamount;
@ -563,7 +563,7 @@ AllocatePixmapPrivateIndex()
}
_X_EXPORT Bool
AllocatePixmapPrivate(register ScreenPtr pScreen, int index2, unsigned amount)
AllocatePixmapPrivate(ScreenPtr pScreen, int index2, unsigned amount)
{
unsigned oldamount;

6
dix/property.c
View File

@ -76,7 +76,7 @@ static void
PrintPropertys(WindowPtr pWin)
{
PropertyPtr pProp;
register int j;
int j;
pProp = pWin->userProps;
while (pProp)
@ -110,7 +110,7 @@ ProcRotateProperties(ClientPtr client)
int i, j, delta, rc;
REQUEST(xRotatePropertiesReq);
WindowPtr pWin;
register Atom * atoms;
Atom * atoms;
PropertyPtr * props; /* array of pointer */
PropertyPtr pProp;
xEvent event;
@ -652,7 +652,7 @@ ProcListProperties(ClientPtr client)
}
int
ProcDeleteProperty(register ClientPtr client)
ProcDeleteProperty(ClientPtr client)
{
WindowPtr pWin;
REQUEST(xDeletePropertyReq);

70
dix/resource.c
View File

@ -257,7 +257,7 @@ CreateNewResourceClass()
return next;
}
ClientResourceRec clientTable[MAXCLIENTS];
static ClientResourceRec clientTable[MAXCLIENTS];
/*****************
* InitClientResources
@ -268,7 +268,7 @@ ClientResourceRec clientTable[MAXCLIENTS];
Bool
InitClientResources(ClientPtr client)
{
register int i, j;
int i, j;
if (client == serverClient)
{
@ -325,7 +325,7 @@ InitClientResources(ClientPtr client)
static int
Hash(int client, register XID id)
Hash(int client, XID id)
{
id &= RESOURCE_ID_MASK;
switch (clientTable[client].hashsize)
@ -348,12 +348,12 @@ Hash(int client, register XID id)
static XID
AvailableID(
register int client,
register XID id,
register XID maxid,
register XID goodid)
int client,
XID id,
XID maxid,
XID goodid)
{
register ResourcePtr res;
ResourcePtr res;
if ((goodid >= id) && (goodid <= maxid))
return goodid;
@ -371,10 +371,10 @@ AvailableID(
_X_EXPORT void
GetXIDRange(int client, Bool server, XID *minp, XID *maxp)
{
register XID id, maxid;
register ResourcePtr *resp;
register ResourcePtr res;
register int i;
XID id, maxid;
ResourcePtr *resp;
ResourcePtr res;
int i;
XID goodid;
id = (Mask)client << CLIENTOFFSET;
@ -447,7 +447,7 @@ GetXIDList(ClientPtr pClient, unsigned count, XID *pids)
*/
_X_EXPORT XID
FakeClientID(register int client)
FakeClientID(int client)
{
XID id, maxid;
@ -471,8 +471,8 @@ _X_EXPORT Bool
AddResource(XID id, RESTYPE type, pointer value)
{
int client;
register ClientResourceRec *rrec;
register ResourcePtr res, *head;
ClientResourceRec *rrec;
ResourcePtr res, *head;
#ifdef XSERVER_DTRACE
XSERVER_RESOURCE_ALLOC(id, type, value, TypeNameString(type));
@ -510,10 +510,10 @@ AddResource(XID id, RESTYPE type, pointer value)
static void
RebuildTable(int client)
{
register int j;
register ResourcePtr res, next;
int j;
ResourcePtr res, next;
ResourcePtr **tails, *resources;
register ResourcePtr **tptr, *rptr;
ResourcePtr **tptr, *rptr;
/*
* For now, preserve insertion order, since some ddx layers depend
@ -560,9 +560,9 @@ _X_EXPORT void
FreeResource(XID id, RESTYPE skipDeleteFuncType)
{
int cid;
register ResourcePtr res;
register ResourcePtr *prev, *head;
register int *eltptr;
ResourcePtr res;
ResourcePtr *prev, *head;
int *eltptr;
int elements;
Bool gotOne = FALSE;
@ -615,8 +615,8 @@ _X_EXPORT void
FreeResourceByType(XID id, RESTYPE type, Bool skipFree)
{
int cid;
register ResourcePtr res;
register ResourcePtr *prev, *head;
ResourcePtr res;
ResourcePtr *prev, *head;
if (((cid = CLIENT_ID(id)) < MAXCLIENTS) && clientTable[cid].buckets)
{
head = &clientTable[cid].resources[Hash(cid, id)];
@ -662,7 +662,7 @@ _X_EXPORT Bool
ChangeResourceValue (XID id, RESTYPE rtype, pointer value)
{
int cid;
register ResourcePtr res;
ResourcePtr res;
if (((cid = CLIENT_ID(id)) < MAXCLIENTS) && clientTable[cid].buckets)
{
@ -693,10 +693,10 @@ FindClientResourcesByType(
FindResType func,
pointer cdata
){
register ResourcePtr *resources;
register ResourcePtr this, next;
ResourcePtr *resources;
ResourcePtr this, next;
int i, elements;
register int *eltptr;
int *eltptr;
if (!client)
client = serverClient;
@ -724,10 +724,10 @@ FindAllClientResources(
FindAllRes func,
pointer cdata
){
register ResourcePtr *resources;
register ResourcePtr this, next;
ResourcePtr *resources;
ResourcePtr this, next;
int i, elements;
register int *eltptr;
int *eltptr;
if (!client)
client = serverClient;
@ -817,8 +817,8 @@ FreeClientNeverRetainResources(ClientPtr client)
void
FreeClientResources(ClientPtr client)
{
register ResourcePtr *resources;
register ResourcePtr this;
ResourcePtr *resources;
ResourcePtr this;
int j;
/* This routine shouldn't be called with a null client, but just in
@ -880,7 +880,7 @@ FreeAllResources()
}
_X_EXPORT Bool
LegalNewID(XID id, register ClientPtr client)
LegalNewID(XID id, ClientPtr client)
{
#ifdef PANORAMIX
@ -911,7 +911,7 @@ _X_EXPORT pointer
SecurityLookupIDByType(ClientPtr client, XID id, RESTYPE rtype, Mask mode)
{
int cid;
register ResourcePtr res;
ResourcePtr res;
pointer retval = NULL;
if (((cid = CLIENT_ID(id)) < MAXCLIENTS) &&
@ -938,7 +938,7 @@ _X_EXPORT pointer
SecurityLookupIDByClass(ClientPtr client, XID id, RESTYPE classes, Mask mode)
{
int cid;
register ResourcePtr res = NULL;
ResourcePtr res = NULL;
pointer retval = NULL;
if (((cid = CLIENT_ID(id)) < MAXCLIENTS) &&

199
dix/swaprep.c
View File

@ -73,10 +73,10 @@ static void SwapFont(xQueryFontReply *pr, Bool hasGlyphs);
* \param size size in bytes
*/
_X_EXPORT void
Swap32Write(ClientPtr pClient, int size, register CARD32 *pbuf)
Swap32Write(ClientPtr pClient, int size, CARD32 *pbuf)
{
register int i;
register char n;
int i;
char n;
size >>= 2;
for(i = 0; i < size; i++)
@ -97,7 +97,7 @@ CopySwap32Write(ClientPtr pClient, int size, CARD32 *pbuf)
{
int bufsize = size;
CARD32 *pbufT;
register CARD32 *from, *to, *fromLast, *toLast;
CARD32 *from, *to, *fromLast, *toLast;
CARD32 tmpbuf[1];
/* Allocate as big a buffer as we can... */
@ -145,7 +145,7 @@ CopySwap16Write(ClientPtr pClient, int size, short *pbuf)
{
int bufsize = size;
short *pbufT;
register short *from, *to, *fromLast, *toLast;
short *from, *to, *fromLast, *toLast;
short tmpbuf[2];
/* Allocate as big a buffer as we can... */
@ -189,7 +189,7 @@ CopySwap16Write(ClientPtr pClient, int size, short *pbuf)
void
SGenericReply(ClientPtr pClient, int size, xGenericReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
(void)WriteToClient(pClient, size, (char *) pRep);
@ -200,7 +200,7 @@ void
SGetWindowAttributesReply(ClientPtr pClient, int size,
xGetWindowAttributesReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -218,7 +218,7 @@ SGetWindowAttributesReply(ClientPtr pClient, int size,
void
SGetGeometryReply(ClientPtr pClient, int size, xGetGeometryReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->root, n);
@ -233,7 +233,7 @@ SGetGeometryReply(ClientPtr pClient, int size, xGetGeometryReply *pRep)
void
SQueryTreeReply(ClientPtr pClient, int size, xQueryTreeReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -246,7 +246,7 @@ SQueryTreeReply(ClientPtr pClient, int size, xQueryTreeReply *pRep)
void
SInternAtomReply(ClientPtr pClient, int size, xInternAtomReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->atom, n);
@ -256,7 +256,7 @@ SInternAtomReply(ClientPtr pClient, int size, xInternAtomReply *pRep)
void
SGetAtomNameReply(ClientPtr pClient, int size, xGetAtomNameReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -268,7 +268,7 @@ SGetAtomNameReply(ClientPtr pClient, int size, xGetAtomNameReply *pRep)
void
SGetPropertyReply(ClientPtr pClient, int size, xGetPropertyReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -281,7 +281,7 @@ SGetPropertyReply(ClientPtr pClient, int size, xGetPropertyReply *pRep)
void
SListPropertiesReply(ClientPtr pClient, int size, xListPropertiesReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -293,7 +293,7 @@ void
SGetSelectionOwnerReply(ClientPtr pClient, int size,
xGetSelectionOwnerReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->owner, n);
@ -304,7 +304,7 @@ SGetSelectionOwnerReply(ClientPtr pClient, int size,
void
SQueryPointerReply(ClientPtr pClient, int size, xQueryPointerReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->root, n);
@ -317,10 +317,10 @@ SQueryPointerReply(ClientPtr pClient, int size, xQueryPointerReply *pRep)
(void)WriteToClient(pClient, size, (char *) pRep);
}
void
static void
SwapTimecoord(xTimecoord* pCoord)
{
register char n;
char n;
swapl(&pCoord->time, n);
swaps(&pCoord->x, n);
@ -346,7 +346,7 @@ SwapTimeCoordWrite(ClientPtr pClient, int size, xTimecoord *pRep)
void
SGetMotionEventsReply(ClientPtr pClient, int size, xGetMotionEventsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -357,7 +357,7 @@ SGetMotionEventsReply(ClientPtr pClient, int size, xGetMotionEventsReply *pRep)
void
STranslateCoordsReply(ClientPtr pClient, int size, xTranslateCoordsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->child, n);
@ -369,7 +369,7 @@ STranslateCoordsReply(ClientPtr pClient, int size, xTranslateCoordsReply *pRep)
void
SGetInputFocusReply(ClientPtr pClient, int size, xGetInputFocusReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->focus, n);
@ -380,7 +380,7 @@ SGetInputFocusReply(ClientPtr pClient, int size, xGetInputFocusReply *pRep)
void
SQueryKeymapReply(ClientPtr pClient, int size, xQueryKeymapReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -390,7 +390,7 @@ SQueryKeymapReply(ClientPtr pClient, int size, xQueryKeymapReply *pRep)
static void
SwapCharInfo(xCharInfo *pInfo)
{
register char n;
char n;
swaps(&pInfo->leftSideBearing, n);
swaps(&pInfo->rightSideBearing, n);
@ -403,7 +403,7 @@ SwapCharInfo(xCharInfo *pInfo)
static void
SwapFontInfo(xQueryFontReply *pr)
{
register char n;
char n;
swaps(&pr->minCharOrByte2, n);
swaps(&pr->maxCharOrByte2, n);
@ -423,7 +423,7 @@ SwapFont(xQueryFontReply *pr, Bool hasGlyphs)
xCharInfo * pxci;
unsigned nchars, nprops;
char *pby;
register char n;
char n;
swaps(&pr->sequenceNumber, n);
swapl(&pr->length, n);
@ -458,7 +458,7 @@ SQueryFontReply(ClientPtr pClient, int size, xQueryFontReply *pRep)
void
SQueryTextExtentsReply(ClientPtr pClient, int size, xQueryTextExtentsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swaps(&pRep->fontAscent, n);
@ -474,7 +474,7 @@ SQueryTextExtentsReply(ClientPtr pClient, int size, xQueryTextExtentsReply *pRep
void
SListFontsReply(ClientPtr pClient, int size, xListFontsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -493,7 +493,7 @@ SListFontsWithInfoReply(ClientPtr pClient, int size,
void
SGetFontPathReply(ClientPtr pClient, int size, xGetFontPathReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -504,7 +504,7 @@ SGetFontPathReply(ClientPtr pClient, int size, xGetFontPathReply *pRep)
void
SGetImageReply(ClientPtr pClient, int size, xGetImageReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -517,7 +517,7 @@ void
SListInstalledColormapsReply(ClientPtr pClient, int size,
xListInstalledColormapsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -531,7 +531,7 @@ SAllocColorReply(pClient, size, pRep)
int size;
xAllocColorReply *pRep;
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swaps(&pRep->red, n);
@ -544,7 +544,7 @@ SAllocColorReply(pClient, size, pRep)
void
SAllocNamedColorReply(ClientPtr pClient, int size, xAllocNamedColorReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->pixel, n);
@ -560,7 +560,7 @@ SAllocNamedColorReply(ClientPtr pClient, int size, xAllocNamedColorReply *pRep)
void
SAllocColorCellsReply(ClientPtr pClient, int size, xAllocColorCellsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -573,7 +573,7 @@ SAllocColorCellsReply(ClientPtr pClient, int size, xAllocColorCellsReply *pRep)
void
SAllocColorPlanesReply(ClientPtr pClient, int size, xAllocColorPlanesReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -584,10 +584,10 @@ SAllocColorPlanesReply(ClientPtr pClient, int size, xAllocColorPlanesReply *pRep
(void)WriteToClient(pClient, size, (char *) pRep);
}
void
static void
SwapRGB(xrgb *prgb)
{
register char n;
char n;
swaps(&prgb->red, n);
swaps(&prgb->green, n);
@ -613,7 +613,7 @@ SQColorsExtend(ClientPtr pClient, int size, xrgb *prgb)
void
SQueryColorsReply(ClientPtr pClient, int size, xQueryColorsReply* pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -624,7 +624,7 @@ SQueryColorsReply(ClientPtr pClient, int size, xQueryColorsReply* pRep)
void
SLookupColorReply(ClientPtr pClient, int size, xLookupColorReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swaps(&pRep->exactRed, n);
@ -639,7 +639,7 @@ SLookupColorReply(ClientPtr pClient, int size, xLookupColorReply *pRep)
void
SQueryBestSizeReply(ClientPtr pClient, int size, xQueryBestSizeReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swaps(&pRep->width, n);
@ -650,7 +650,7 @@ SQueryBestSizeReply(ClientPtr pClient, int size, xQueryBestSizeReply *pRep)
void
SListExtensionsReply(ClientPtr pClient, int size, xListExtensionsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -661,7 +661,7 @@ void
SGetKeyboardMappingReply(ClientPtr pClient, int size,
xGetKeyboardMappingReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -672,7 +672,7 @@ void
SGetPointerMappingReply(ClientPtr pClient, int size,
xGetPointerMappingReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -683,7 +683,7 @@ void
SGetModifierMappingReply(ClientPtr pClient, int size,
xGetModifierMappingReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -693,7 +693,7 @@ SGetModifierMappingReply(ClientPtr pClient, int size,
void
SGetKeyboardControlReply(ClientPtr pClient, int size, xGetKeyboardControlReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -706,7 +706,7 @@ SGetKeyboardControlReply(ClientPtr pClient, int size, xGetKeyboardControlReply *
void
SGetPointerControlReply(ClientPtr pClient, int size, xGetPointerControlReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swaps(&pRep->accelNumerator, n);
@ -718,7 +718,7 @@ SGetPointerControlReply(ClientPtr pClient, int size, xGetPointerControlReply *pR
void
SGetScreenSaverReply(ClientPtr pClient, int size, xGetScreenSaverReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swaps(&pRep->timeout, n);
@ -734,7 +734,7 @@ SLHostsExtend(ClientPtr pClient, int size, char *buf)
while (bufT < endbuf) {
xHostEntry *host = (xHostEntry *) bufT;
int len = host->length;
register char n;
char n;
swaps (&host->length, n);
bufT += sizeof (xHostEntry) + (((len + 3) >> 2) << 2);
}
@ -744,7 +744,7 @@ SLHostsExtend(ClientPtr pClient, int size, char *buf)
void
SListHostsReply(ClientPtr pClient, int size, xListHostsReply *pRep)
{
register char n;
char n;
swaps(&pRep->sequenceNumber, n);
swapl(&pRep->length, n);
@ -1159,6 +1159,58 @@ SKeymapNotifyEvent(xEvent *from, xEvent *to)
*to = *from;
}
static void
SwapConnSetup(xConnSetup *pConnSetup, xConnSetup *pConnSetupT)
{
cpswapl(pConnSetup->release, pConnSetupT->release);
cpswapl(pConnSetup->ridBase, pConnSetupT->ridBase);
cpswapl(pConnSetup->ridMask, pConnSetupT->ridMask);
cpswapl(pConnSetup->motionBufferSize, pConnSetupT->motionBufferSize);
cpswaps(pConnSetup->nbytesVendor, pConnSetupT->nbytesVendor);
cpswaps(pConnSetup->maxRequestSize, pConnSetupT->maxRequestSize);
pConnSetupT->minKeyCode = pConnSetup->minKeyCode;
pConnSetupT->maxKeyCode = pConnSetup->maxKeyCode;
pConnSetupT->numRoots = pConnSetup->numRoots;
pConnSetupT->numFormats = pConnSetup->numFormats;
pConnSetupT->imageByteOrder = pConnSetup->imageByteOrder;
pConnSetupT->bitmapBitOrder = pConnSetup->bitmapBitOrder;
pConnSetupT->bitmapScanlineUnit = pConnSetup->bitmapScanlineUnit;
pConnSetupT->bitmapScanlinePad = pConnSetup->bitmapScanlinePad;
}
static void
SwapWinRoot(xWindowRoot *pRoot, xWindowRoot *pRootT)
{
cpswapl(pRoot->windowId, pRootT->windowId);
cpswapl(pRoot->defaultColormap, pRootT->defaultColormap);
cpswapl(pRoot->whitePixel, pRootT->whitePixel);
cpswapl(pRoot->blackPixel, pRootT->blackPixel);
cpswapl(pRoot->currentInputMask, pRootT->currentInputMask);
cpswaps(pRoot->pixWidth, pRootT->pixWidth);
cpswaps(pRoot->pixHeight, pRootT->pixHeight);
cpswaps(pRoot->mmWidth, pRootT->mmWidth);
cpswaps(pRoot->mmHeight, pRootT->mmHeight);
cpswaps(pRoot->minInstalledMaps, pRootT->minInstalledMaps);
cpswaps(pRoot->maxInstalledMaps, pRootT->maxInstalledMaps);
cpswapl(pRoot->rootVisualID, pRootT->rootVisualID);
pRootT->backingStore = pRoot->backingStore;
pRootT->saveUnders = pRoot->saveUnders;
pRootT->rootDepth = pRoot->rootDepth;
pRootT->nDepths = pRoot->nDepths;
}
static void
SwapVisual(xVisualType *pVis, xVisualType *pVisT)
{
cpswapl(pVis->visualID, pVisT->visualID);
pVisT->class = pVis->class;
pVisT->bitsPerRGB = pVis->bitsPerRGB;
cpswaps(pVis->colormapEntries, pVisT->colormapEntries);
cpswapl(pVis->redMask, pVisT->redMask);
cpswapl(pVis->greenMask, pVisT->greenMask);
cpswapl(pVis->blueMask, pVisT->blueMask);
}
_X_EXPORT void
SwapConnSetupInfo(
char *pInfo,
@ -1210,7 +1262,6 @@ SwapConnSetupInfo(
}
}
void
WriteSConnectionInfo(ClientPtr pClient, unsigned long size, char *pInfo)
{
@ -1227,58 +1278,6 @@ WriteSConnectionInfo(ClientPtr pClient, unsigned long size, char *pInfo)
DEALLOCATE_LOCAL(pInfoTBase);
}
void
SwapConnSetup(xConnSetup *pConnSetup, xConnSetup *pConnSetupT)
{
cpswapl(pConnSetup->release, pConnSetupT->release);
cpswapl(pConnSetup->ridBase, pConnSetupT->ridBase);
cpswapl(pConnSetup->ridMask, pConnSetupT->ridMask);
cpswapl(pConnSetup->motionBufferSize, pConnSetupT->motionBufferSize);
cpswaps(pConnSetup->nbytesVendor, pConnSetupT->nbytesVendor);
cpswaps(pConnSetup->maxRequestSize, pConnSetupT->maxRequestSize);
pConnSetupT->minKeyCode = pConnSetup->minKeyCode;
pConnSetupT->maxKeyCode = pConnSetup->maxKeyCode;
pConnSetupT->numRoots = pConnSetup->numRoots;
pConnSetupT->numFormats = pConnSetup->numFormats;
pConnSetupT->imageByteOrder = pConnSetup->imageByteOrder;
pConnSetupT->bitmapBitOrder = pConnSetup->bitmapBitOrder;
pConnSetupT->bitmapScanlineUnit = pConnSetup->bitmapScanlineUnit;
pConnSetupT->bitmapScanlinePad = pConnSetup->bitmapScanlinePad;
}
void
SwapWinRoot(xWindowRoot *pRoot, xWindowRoot *pRootT)
{
cpswapl(pRoot->windowId, pRootT->windowId);
cpswapl(pRoot->defaultColormap, pRootT->defaultColormap);
cpswapl(pRoot->whitePixel, pRootT->whitePixel);
cpswapl(pRoot->blackPixel, pRootT->blackPixel);
cpswapl(pRoot->currentInputMask, pRootT->currentInputMask);
cpswaps(pRoot->pixWidth, pRootT->pixWidth);
cpswaps(pRoot->pixHeight, pRootT->pixHeight);
cpswaps(pRoot->mmWidth, pRootT->mmWidth);
cpswaps(pRoot->mmHeight, pRootT->mmHeight);
cpswaps(pRoot->minInstalledMaps, pRootT->minInstalledMaps);
cpswaps(pRoot->maxInstalledMaps, pRootT->maxInstalledMaps);
cpswapl(pRoot->rootVisualID, pRootT->rootVisualID);
pRootT->backingStore = pRoot->backingStore;
pRootT->saveUnders = pRoot->saveUnders;
pRootT->rootDepth = pRoot->rootDepth;
pRootT->nDepths = pRoot->nDepths;
}
void
SwapVisual(xVisualType *pVis, xVisualType *pVisT)
{
cpswapl(pVis->visualID, pVisT->visualID);
pVisT->class = pVis->class;
pVisT->bitsPerRGB = pVis->bitsPerRGB;
cpswaps(pVis->colormapEntries, pVisT->colormapEntries);
cpswapl(pVis->redMask, pVisT->redMask);
cpswapl(pVis->greenMask, pVisT->greenMask);
cpswapl(pVis->blueMask, pVisT->blueMask);
}
_X_EXPORT void
SwapConnSetupPrefix(xConnSetupPrefix *pcspFrom, xConnSetupPrefix *pcspTo)
{

276
dix/swapreq.c
View File

@ -63,9 +63,9 @@ SOFTWARE.
/* Byte swap a list of longs */
_X_EXPORT void
SwapLongs (register CARD32 *list, register unsigned long count)
SwapLongs (CARD32 *list, unsigned long count)
{
register char n;
char n;
while (count >= 8) {
swapl(list+0, n);
@ -89,9 +89,9 @@ SwapLongs (register CARD32 *list, register unsigned long count)
/* Byte swap a list of shorts */
_X_EXPORT void
SwapShorts (register short *list, register unsigned long count)
SwapShorts (short *list, unsigned long count)
{
register char n;
char n;
while (count >= 16) {
swaps(list+0, n);
@ -124,9 +124,9 @@ SwapShorts (register short *list, register unsigned long count)
/* The following is used for all requests that have
no fields to be swapped (except "length") */
int
SProcSimpleReq(register ClientPtr client)
SProcSimpleReq(ClientPtr client)
{
register char n;
char n;
REQUEST(xReq);
swaps(&stuff->length, n);
@ -137,9 +137,9 @@ SProcSimpleReq(register ClientPtr client)
only a single 32-bit field to be swapped, coming
right after the "length" field */
int
SProcResourceReq(register ClientPtr client)
SProcResourceReq(ClientPtr client)
{
register char n;
char n;
REQUEST(xResourceReq);
swaps(&stuff->length, n);
@ -149,9 +149,9 @@ SProcResourceReq(register ClientPtr client)
}
int
SProcCreateWindow(register ClientPtr client)
SProcCreateWindow(ClientPtr client)
{
register char n;
char n;
REQUEST(xCreateWindowReq);
swaps(&stuff->length, n);
@ -171,9 +171,9 @@ SProcCreateWindow(register ClientPtr client)
}
int
SProcChangeWindowAttributes(register ClientPtr client)
SProcChangeWindowAttributes(ClientPtr client)
{
register char n;
char n;
REQUEST(xChangeWindowAttributesReq);
swaps(&stuff->length, n);
@ -185,9 +185,9 @@ SProcChangeWindowAttributes(register ClientPtr client)
}
int
SProcReparentWindow(register ClientPtr client)
SProcReparentWindow(ClientPtr client)
{
register char n;
char n;
REQUEST(xReparentWindowReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xReparentWindowReq);
@ -199,9 +199,9 @@ SProcReparentWindow(register ClientPtr client)
}
int
SProcConfigureWindow(register ClientPtr client)
SProcConfigureWindow(ClientPtr client)
{
register char n;
char n;
REQUEST(xConfigureWindowReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
@ -214,9 +214,9 @@ SProcConfigureWindow(register ClientPtr client)
int
SProcInternAtom(register ClientPtr client)
SProcInternAtom(ClientPtr client)
{
register char n;
char n;
REQUEST(xInternAtomReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xInternAtomReq);
@ -225,9 +225,9 @@ SProcInternAtom(register ClientPtr client)
}
int
SProcChangeProperty(register ClientPtr client)
SProcChangeProperty(ClientPtr client)
{
register char n;
char n;
REQUEST(xChangePropertyReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
@ -249,9 +249,9 @@ SProcChangeProperty(register ClientPtr client)
}
int
SProcDeleteProperty(register ClientPtr client)
SProcDeleteProperty(ClientPtr client)
{
register char n;
char n;
REQUEST(xDeletePropertyReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xDeletePropertyReq);
@ -262,9 +262,9 @@ SProcDeleteProperty(register ClientPtr client)
}
int
SProcGetProperty(register ClientPtr client)
SProcGetProperty(ClientPtr client)
{
register char n;
char n;
REQUEST(xGetPropertyReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGetPropertyReq);
@ -277,9 +277,9 @@ SProcGetProperty(register ClientPtr client)
}
int
SProcSetSelectionOwner(register ClientPtr client)
SProcSetSelectionOwner(ClientPtr client)
{
register char n;
char n;
REQUEST(xSetSelectionOwnerReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xSetSelectionOwnerReq);
@ -290,9 +290,9 @@ SProcSetSelectionOwner(register ClientPtr client)
}
int
SProcConvertSelection(register ClientPtr client)
SProcConvertSelection(ClientPtr client)
{
register char n;
char n;
REQUEST(xConvertSelectionReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xConvertSelectionReq);
@ -305,9 +305,9 @@ SProcConvertSelection(register ClientPtr client)
}
int
SProcSendEvent(register ClientPtr client)
SProcSendEvent(ClientPtr client)
{
register char n;
char n;
xEvent eventT;
EventSwapPtr proc;
REQUEST(xSendEventReq);
@ -327,9 +327,9 @@ SProcSendEvent(register ClientPtr client)
}
int
SProcGrabPointer(register ClientPtr client)
SProcGrabPointer(ClientPtr client)
{
register char n;
char n;
REQUEST(xGrabPointerReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGrabPointerReq);
@ -342,9 +342,9 @@ SProcGrabPointer(register ClientPtr client)
}
int
SProcGrabButton(register ClientPtr client)
SProcGrabButton(ClientPtr client)
{
register char n;
char n;
REQUEST(xGrabButtonReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGrabButtonReq);
@ -357,9 +357,9 @@ SProcGrabButton(register ClientPtr client)
}
int
SProcUngrabButton(register ClientPtr client)
SProcUngrabButton(ClientPtr client)
{
register char n;
char n;
REQUEST(xUngrabButtonReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xUngrabButtonReq);
@ -369,9 +369,9 @@ SProcUngrabButton(register ClientPtr client)
}
int
SProcChangeActivePointerGrab(register ClientPtr client)
SProcChangeActivePointerGrab(ClientPtr client)
{
register char n;
char n;
REQUEST(xChangeActivePointerGrabReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xChangeActivePointerGrabReq);
@ -382,9 +382,9 @@ SProcChangeActivePointerGrab(register ClientPtr client)
}
int
SProcGrabKeyboard(register ClientPtr client)
SProcGrabKeyboard(ClientPtr client)
{
register char n;
char n;
REQUEST(xGrabKeyboardReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGrabKeyboardReq);
@ -394,9 +394,9 @@ SProcGrabKeyboard(register ClientPtr client)
}
int
SProcGrabKey(register ClientPtr client)
SProcGrabKey(ClientPtr client)
{
register char n;
char n;
REQUEST(xGrabKeyReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGrabKeyReq);
@ -406,9 +406,9 @@ SProcGrabKey(register ClientPtr client)
}
int
SProcUngrabKey(register ClientPtr client)
SProcUngrabKey(ClientPtr client)
{
register char n;
char n;
REQUEST(xUngrabKeyReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xUngrabKeyReq);
@ -418,9 +418,9 @@ SProcUngrabKey(register ClientPtr client)
}
int
SProcGetMotionEvents(register ClientPtr client)
SProcGetMotionEvents(ClientPtr client)
{
register char n;
char n;
REQUEST(xGetMotionEventsReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGetMotionEventsReq);
@ -431,9 +431,9 @@ SProcGetMotionEvents(register ClientPtr client)
}
int
SProcTranslateCoords(register ClientPtr client)
SProcTranslateCoords(ClientPtr client)
{
register char n;
char n;
REQUEST(xTranslateCoordsReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xTranslateCoordsReq);
@ -445,9 +445,9 @@ SProcTranslateCoords(register ClientPtr client)
}
int
SProcWarpPointer(register ClientPtr client)
SProcWarpPointer(ClientPtr client)
{
register char n;
char n;
REQUEST(xWarpPointerReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xWarpPointerReq);
@ -463,9 +463,9 @@ SProcWarpPointer(register ClientPtr client)
}
int
SProcSetInputFocus(register ClientPtr client)
SProcSetInputFocus(ClientPtr client)
{
register char n;
char n;
REQUEST(xSetInputFocusReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xSetInputFocusReq);
@ -475,9 +475,9 @@ SProcSetInputFocus(register ClientPtr client)
}
int
SProcOpenFont(register ClientPtr client)
SProcOpenFont(ClientPtr client)
{
register char n;
char n;
REQUEST(xOpenFontReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xOpenFontReq);
@ -487,9 +487,9 @@ SProcOpenFont(register ClientPtr client)
}
int
SProcListFonts(register ClientPtr client)
SProcListFonts(ClientPtr client)
{
register char n;
char n;
REQUEST(xListFontsReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xListFontsReq);
@ -499,9 +499,9 @@ SProcListFonts(register ClientPtr client)
}
int
SProcListFontsWithInfo(register ClientPtr client)
SProcListFontsWithInfo(ClientPtr client)
{
register char n;
char n;
REQUEST(xListFontsWithInfoReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xListFontsWithInfoReq);
@ -511,9 +511,9 @@ SProcListFontsWithInfo(register ClientPtr client)
}
int
SProcSetFontPath(register ClientPtr client)
SProcSetFontPath(ClientPtr client)
{
register char n;
char n;
REQUEST(xSetFontPathReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xSetFontPathReq);
@ -522,9 +522,9 @@ SProcSetFontPath(register ClientPtr client)
}
int
SProcCreatePixmap(register ClientPtr client)
SProcCreatePixmap(ClientPtr client)
{
register char n;
char n;
REQUEST(xCreatePixmapReq);
swaps(&stuff->length, n);
@ -537,9 +537,9 @@ SProcCreatePixmap(register ClientPtr client)
}
int
SProcCreateGC(register ClientPtr client)
SProcCreateGC(ClientPtr client)
{
register char n;
char n;
REQUEST(xCreateGCReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xCreateGCReq);
@ -551,9 +551,9 @@ SProcCreateGC(register ClientPtr client)
}
int
SProcChangeGC(register ClientPtr client)
SProcChangeGC(ClientPtr client)
{
register char n;
char n;
REQUEST(xChangeGCReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xChangeGCReq);
@ -564,9 +564,9 @@ SProcChangeGC(register ClientPtr client)
}
int
SProcCopyGC(register ClientPtr client)
SProcCopyGC(ClientPtr client)
{
register char n;
char n;
REQUEST(xCopyGCReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCopyGCReq);
@ -577,9 +577,9 @@ SProcCopyGC(register ClientPtr client)
}
int
SProcSetDashes(register ClientPtr client)
SProcSetDashes(ClientPtr client)
{
register char n;
char n;
REQUEST(xSetDashesReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xSetDashesReq);
@ -591,9 +591,9 @@ SProcSetDashes(register ClientPtr client)
}
int
SProcSetClipRectangles(register ClientPtr client)
SProcSetClipRectangles(ClientPtr client)
{
register char n;
char n;
REQUEST(xSetClipRectanglesReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xSetClipRectanglesReq);
@ -605,9 +605,9 @@ SProcSetClipRectangles(register ClientPtr client)
}
int
SProcClearToBackground(register ClientPtr client)
SProcClearToBackground(ClientPtr client)
{
register char n;
char n;
REQUEST(xClearAreaReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xClearAreaReq);
@ -620,9 +620,9 @@ SProcClearToBackground(register ClientPtr client)
}
int
SProcCopyArea(register ClientPtr client)
SProcCopyArea(ClientPtr client)
{
register char n;
char n;
REQUEST(xCopyAreaReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCopyAreaReq);
@ -639,9 +639,9 @@ SProcCopyArea(register ClientPtr client)
}
int
SProcCopyPlane(register ClientPtr client)
SProcCopyPlane(ClientPtr client)
{
register char n;
char n;
REQUEST(xCopyPlaneReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCopyPlaneReq);
@ -661,9 +661,9 @@ SProcCopyPlane(register ClientPtr client)
/* The following routine is used for all Poly drawing requests
(except FillPoly, which uses a different request format) */
int
SProcPoly(register ClientPtr client)
SProcPoly(ClientPtr client)
{
register char n;
char n;
REQUEST(xPolyPointReq);
swaps(&stuff->length, n);
@ -678,9 +678,9 @@ SProcPoly(register ClientPtr client)
is longer than xPolyPointReq, and we don't want to swap
the difference as shorts! */
int
SProcFillPoly(register ClientPtr client)
SProcFillPoly(ClientPtr client)
{
register char n;
char n;
REQUEST(xFillPolyReq);
swaps(&stuff->length, n);
@ -692,9 +692,9 @@ SProcFillPoly(register ClientPtr client)
}
int
SProcPutImage(register ClientPtr client)
SProcPutImage(ClientPtr client)
{
register char n;
char n;
REQUEST(xPutImageReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xPutImageReq);
@ -710,9 +710,9 @@ SProcPutImage(register ClientPtr client)
}
int
SProcGetImage(register ClientPtr client)
SProcGetImage(ClientPtr client)
{
register char n;
char n;
REQUEST(xGetImageReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xGetImageReq);
@ -728,9 +728,9 @@ SProcGetImage(register ClientPtr client)
/* ProcPolyText used for both PolyText8 and PolyText16 */
int
SProcPolyText(register ClientPtr client)
SProcPolyText(ClientPtr client)
{
register char n;
char n;
REQUEST(xPolyTextReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xPolyTextReq);
@ -744,9 +744,9 @@ SProcPolyText(register ClientPtr client)
/* ProcImageText used for both ImageText8 and ImageText16 */
int
SProcImageText(register ClientPtr client)
SProcImageText(ClientPtr client)
{
register char n;
char n;
REQUEST(xImageTextReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xImageTextReq);
@ -758,9 +758,9 @@ SProcImageText(register ClientPtr client)
}
int
SProcCreateColormap(register ClientPtr client)
SProcCreateColormap(ClientPtr client)
{
register char n;
char n;
REQUEST(xCreateColormapReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCreateColormapReq);
@ -772,9 +772,9 @@ SProcCreateColormap(register ClientPtr client)
int
SProcCopyColormapAndFree(register ClientPtr client)
SProcCopyColormapAndFree(ClientPtr client)
{
register char n;
char n;
REQUEST(xCopyColormapAndFreeReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCopyColormapAndFreeReq);
@ -785,9 +785,9 @@ SProcCopyColormapAndFree(register ClientPtr client)
}
int
SProcAllocColor(register ClientPtr client)
SProcAllocColor(ClientPtr client)
{
register char n;
char n;
REQUEST(xAllocColorReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xAllocColorReq);
@ -799,9 +799,9 @@ SProcAllocColor(register ClientPtr client)
}
int
SProcAllocNamedColor(register ClientPtr client)
SProcAllocNamedColor(ClientPtr client)
{
register char n;
char n;
REQUEST(xAllocNamedColorReq);
swaps(&stuff->length, n);
@ -812,9 +812,9 @@ SProcAllocNamedColor(register ClientPtr client)
}
int
SProcAllocColorCells(register ClientPtr client)
SProcAllocColorCells(ClientPtr client)
{
register char n;
char n;
REQUEST(xAllocColorCellsReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xAllocColorCellsReq);
@ -825,9 +825,9 @@ SProcAllocColorCells(register ClientPtr client)
}
int
SProcAllocColorPlanes(register ClientPtr client)
SProcAllocColorPlanes(ClientPtr client)
{
register char n;
char n;
REQUEST(xAllocColorPlanesReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xAllocColorPlanesReq);
@ -840,9 +840,9 @@ SProcAllocColorPlanes(register ClientPtr client)
}
int
SProcFreeColors(register ClientPtr client)
SProcFreeColors(ClientPtr client)
{
register char n;
char n;
REQUEST(xFreeColorsReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xFreeColorsReq);
@ -856,7 +856,7 @@ SProcFreeColors(register ClientPtr client)
_X_EXPORT void
SwapColorItem(xColorItem *pItem)
{
register char n;
char n;
swapl(&pItem->pixel, n);
swaps(&pItem->red, n);
@ -865,9 +865,9 @@ SwapColorItem(xColorItem *pItem)
}
int
SProcStoreColors(register ClientPtr client)
SProcStoreColors(ClientPtr client)
{
register char n;
char n;
long count;
xColorItem *pItem;
@ -882,9 +882,9 @@ SProcStoreColors(register ClientPtr client)
}
int
SProcStoreNamedColor (register ClientPtr client)
SProcStoreNamedColor (ClientPtr client)
{
register char n;
char n;
REQUEST(xStoreNamedColorReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xStoreNamedColorReq);
@ -895,9 +895,9 @@ SProcStoreNamedColor (register ClientPtr client)
}
int
SProcQueryColors (register ClientPtr client)
SProcQueryColors (ClientPtr client)
{
register char n;
char n;
REQUEST(xQueryColorsReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xQueryColorsReq);
@ -907,9 +907,9 @@ SProcQueryColors (register ClientPtr client)
}
int
SProcLookupColor (register ClientPtr client)
SProcLookupColor (ClientPtr client)
{
register char n;
char n;
REQUEST(xLookupColorReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xLookupColorReq);
@ -919,9 +919,9 @@ SProcLookupColor (register ClientPtr client)
}
int
SProcCreateCursor (register ClientPtr client)
SProcCreateCursor (ClientPtr client)
{
register char n;
char n;
REQUEST(xCreateCursorReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCreateCursorReq);
@ -940,9 +940,9 @@ SProcCreateCursor (register ClientPtr client)
}
int
SProcCreateGlyphCursor (register ClientPtr client)
SProcCreateGlyphCursor (ClientPtr client)
{
register char n;
char n;
REQUEST(xCreateGlyphCursorReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xCreateGlyphCursorReq);
@ -962,9 +962,9 @@ SProcCreateGlyphCursor (register ClientPtr client)
int
SProcRecolorCursor (register ClientPtr client)
SProcRecolorCursor (ClientPtr client)
{
register char n;
char n;
REQUEST(xRecolorCursorReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xRecolorCursorReq);
@ -979,9 +979,9 @@ SProcRecolorCursor (register ClientPtr client)
}
int
SProcQueryBestSize (register ClientPtr client)
SProcQueryBestSize (ClientPtr client)
{
register char n;
char n;
REQUEST(xQueryBestSizeReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xQueryBestSizeReq);
@ -993,9 +993,9 @@ SProcQueryBestSize (register ClientPtr client)
}
int
SProcQueryExtension (register ClientPtr client)
SProcQueryExtension (ClientPtr client)
{
register char n;
char n;
REQUEST(xQueryExtensionReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xQueryExtensionReq);
@ -1004,9 +1004,9 @@ SProcQueryExtension (register ClientPtr client)
}
int
SProcChangeKeyboardMapping (register ClientPtr client)
SProcChangeKeyboardMapping (ClientPtr client)
{
register char n;
char n;
REQUEST(xChangeKeyboardMappingReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xChangeKeyboardMappingReq);
@ -1016,9 +1016,9 @@ SProcChangeKeyboardMapping (register ClientPtr client)
int
SProcChangeKeyboardControl (register ClientPtr client)
SProcChangeKeyboardControl (ClientPtr client)
{
register char n;
char n;
REQUEST(xChangeKeyboardControlReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xChangeKeyboardControlReq);
@ -1028,9 +1028,9 @@ SProcChangeKeyboardControl (register ClientPtr client)
}
int
SProcChangePointerControl (register ClientPtr client)
SProcChangePointerControl (ClientPtr client)
{
register char n;
char n;
REQUEST(xChangePointerControlReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xChangePointerControlReq);
@ -1042,9 +1042,9 @@ SProcChangePointerControl (register ClientPtr client)
int
SProcSetScreenSaver (register ClientPtr client)
SProcSetScreenSaver (ClientPtr client)
{
register char n;
char n;
REQUEST(xSetScreenSaverReq);
swaps(&stuff->length, n);
REQUEST_SIZE_MATCH(xSetScreenSaverReq);
@ -1054,9 +1054,9 @@ SProcSetScreenSaver (register ClientPtr client)
}
int
SProcChangeHosts (register ClientPtr client)
SProcChangeHosts (ClientPtr client)
{
register char n;
char n;
REQUEST(xChangeHostsReq);
swaps(&stuff->length, n);
@ -1066,9 +1066,9 @@ SProcChangeHosts (register ClientPtr client)
}
int SProcRotateProperties (register ClientPtr client)
int SProcRotateProperties (ClientPtr client)
{
register char n;
char n;
REQUEST(xRotatePropertiesReq);
swaps(&stuff->length, n);
REQUEST_AT_LEAST_SIZE(xRotatePropertiesReq);
@ -1080,9 +1080,9 @@ int SProcRotateProperties (register ClientPtr client)
}
int
SProcNoOperation(register ClientPtr client)
SProcNoOperation(ClientPtr client)
{
register char n;
char n;
REQUEST(xReq);
swaps(&stuff->length, n);
return ((* ProcVector[X_NoOperation])(client));
@ -1091,7 +1091,7 @@ SProcNoOperation(register ClientPtr client)
void
SwapConnClientPrefix(xConnClientPrefix *pCCP)
{
register char n;
char n;
swaps(&pCCP->majorVersion, n);
swaps(&pCCP->minorVersion, n);

320
dix/window.c
View File

@ -220,10 +220,10 @@ PrintWindowTree(void)
#endif
_X_EXPORT int
TraverseTree(register WindowPtr pWin, VisitWindowProcPtr func, pointer data)
TraverseTree(WindowPtr pWin, VisitWindowProcPtr func, pointer data)
{
register int result;
register WindowPtr pChild;
int result;
WindowPtr pChild;
if (!(pChild = pWin))
return(WT_NOMATCH);
@ -269,7 +269,7 @@ Bool enableBackingStore = FALSE;
Bool disableSaveUnders = FALSE;
static void
SetWindowToDefaults(register WindowPtr pWin)
SetWindowToDefaults(WindowPtr pWin)
{
pWin->prevSib = NullWindow;
pWin->firstChild = NullWindow;
@ -297,10 +297,6 @@ SetWindowToDefaults(register WindowPtr pWin)
pWin->deliverableEvents = 0;
pWin->dontPropagate = 0;
pWin->forcedBS = FALSE;
#ifdef NEED_DBE_BUF_BITS
pWin->srcBuffer = DBE_FRONT_BUFFER;
pWin->dstBuffer = DBE_FRONT_BUFFER;
#endif
#ifdef COMPOSITE
pWin->redirectDraw = 0;
#endif
@ -313,8 +309,8 @@ MakeRootTile(WindowPtr pWin)
GCPtr pGC;
unsigned char back[128];
int len = BitmapBytePad(sizeof(long));
register unsigned char *from, *to;
register int i, j;
unsigned char *from, *to;
int i, j;
pWin->background.pixmap = (*pScreen->CreatePixmap)(pScreen, 4, 4,
pScreen->rootDepth);
@ -353,11 +349,11 @@ WindowPtr
AllocateWindow(ScreenPtr pScreen)
{
WindowPtr pWin;
register char *ptr;
register DevUnion *ppriv;
register unsigned *sizes;
register unsigned size;
register int i;
char *ptr;
DevUnion *ppriv;
unsigned *sizes;
unsigned size;
int i;
pWin = (WindowPtr)xalloc(pScreen->totalWindowSize);
if (pWin)
@ -537,10 +533,10 @@ InitRootWindow(WindowPtr pWin)
* window from which the region came.
*/
void
ClippedRegionFromBox(register WindowPtr pWin, RegionPtr Rgn,
register int x, register int y,
register int w, register int h)
static void
ClippedRegionFromBox(WindowPtr pWin, RegionPtr Rgn,
int x, int y,
int w, int h)
{
ScreenPtr pScreen;
BoxRec box;
@ -577,7 +573,7 @@ RegisterRealChildHeadProc (RealChildHeadProc proc)
WindowPtr
RealChildHead(register WindowPtr pWin)
RealChildHead(WindowPtr pWin)
{
if (realChildHeadProc) {
return realChildHeadProc (pWin);
@ -597,19 +593,19 @@ RealChildHead(register WindowPtr pWin)
*****/
_X_EXPORT WindowPtr
CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
unsigned h, unsigned bw, unsigned class, register Mask vmask, XID *vlist,
CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w,
unsigned h, unsigned bw, unsigned class, Mask vmask, XID *vlist,
int depth, ClientPtr client, VisualID visual, int *error)
{
register WindowPtr pWin;
WindowPtr pWin;
WindowPtr pHead;
register ScreenPtr pScreen;
ScreenPtr pScreen;
xEvent event;
int idepth, ivisual;
Bool fOK;
DepthPtr pDepth;
PixmapFormatRec *format;
register WindowOptPtr ancwopt;
WindowOptPtr ancwopt;
if (class == CopyFromParent)
class = pParent->drawable.class;
@ -832,9 +828,29 @@ CreateWindow(Window wid, register WindowPtr pParent, int x, int y, unsigned w,
}
static void
FreeWindowResources(register WindowPtr pWin)
DisposeWindowOptional (WindowPtr pWin)
{
register ScreenPtr pScreen = pWin->drawable.pScreen;
if (!pWin->optional)
return;
/*
* everything is peachy. Delete the optional record
* and clean up
*/
if (pWin->optional->cursor)
{
FreeCursor (pWin->optional->cursor, (Cursor)0);
pWin->cursorIsNone = FALSE;
}
else
pWin->cursorIsNone = TRUE;
xfree (pWin->optional);
pWin->optional = NULL;
}
static void
FreeWindowResources(WindowPtr pWin)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DeleteWindowFromAnySaveSet(pWin);
DeleteWindowFromAnySelections(pWin);
@ -865,7 +881,7 @@ FreeWindowResources(register WindowPtr pWin)
static void
CrushTree(WindowPtr pWin)
{
register WindowPtr pChild, pSib, pParent;
WindowPtr pChild, pSib, pParent;
UnrealizeWindowProcPtr UnrealizeWindow;
xEvent event;
@ -922,8 +938,8 @@ CrushTree(WindowPtr pWin)
int
DeleteWindow(pointer value, XID wid)
{
register WindowPtr pParent;
register WindowPtr pWin = (WindowPtr)value;
WindowPtr pParent;
WindowPtr pWin = (WindowPtr)value;
xEvent event;
UnmapWindow(pWin, FALSE);
@ -955,7 +971,7 @@ DeleteWindow(pointer value, XID wid)
}
void
DestroySubwindows(register WindowPtr pWin, ClientPtr client)
DestroySubwindows(WindowPtr pWin, ClientPtr client)
{
/* XXX
* The protocol is quite clear that each window should be
@ -982,10 +998,10 @@ DestroySubwindows(register WindowPtr pWin, ClientPtr client)
*****/
_X_EXPORT int
ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client)
ChangeWindowAttributes(WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client)
{
register Mask index2;
register XID *pVlist;
Mask index2;
XID *pVlist;
PixmapPtr pPixmap;
Pixmap pixID;
CursorPtr pCursor, pOldCursor;
@ -995,9 +1011,9 @@ ChangeWindowAttributes(register WindowPtr pWin, Mask vmask, XID *vlist, ClientPt
ColormapPtr pCmap;
xEvent xE;
int result;
register ScreenPtr pScreen;
ScreenPtr pScreen;
Mask vmaskCopy = 0;
register Mask tmask;
Mask tmask;
unsigned int val;
int error;
Bool checkOptional = FALSE;
@ -1516,7 +1532,7 @@ PatchUp:
*****/
void
GetWindowAttributes(register WindowPtr pWin, ClientPtr client, xGetWindowAttributesReply *wa)
GetWindowAttributes(WindowPtr pWin, ClientPtr client, xGetWindowAttributesReply *wa)
{
wa->type = X_Reply;
wa->bitGravity = pWin->bitGravity;
@ -1552,9 +1568,9 @@ GetWindowAttributes(register WindowPtr pWin, ClientPtr client, xGetWindowAttribu
_X_EXPORT WindowPtr
MoveWindowInStack(register WindowPtr pWin, register WindowPtr pNextSib)
MoveWindowInStack(WindowPtr pWin, WindowPtr pNextSib)
{
register WindowPtr pParent = pWin->parent;
WindowPtr pParent = pWin->parent;
WindowPtr pFirstChange = pWin; /* highest window where list changes */
if (pWin->nextSib != pNextSib)
@ -1636,7 +1652,7 @@ MoveWindowInStack(register WindowPtr pWin, register WindowPtr pNextSib)
}
_X_EXPORT RegionPtr
CreateUnclippedWinSize (register WindowPtr pWin)
CreateUnclippedWinSize (WindowPtr pWin)
{
RegionPtr pRgn;
BoxRec box;
@ -1664,7 +1680,7 @@ CreateUnclippedWinSize (register WindowPtr pWin)
}
_X_EXPORT void
SetWinSize (register WindowPtr pWin)
SetWinSize (WindowPtr pWin)
{
#ifdef COMPOSITE
if (pWin->redirectDraw)
@ -1703,7 +1719,7 @@ SetWinSize (register WindowPtr pWin)
}
_X_EXPORT void
SetBorderSize (register WindowPtr pWin)
SetBorderSize (WindowPtr pWin)
{
int bw;
@ -1755,9 +1771,9 @@ SetBorderSize (register WindowPtr pWin)
*/
_X_EXPORT void
GravityTranslate (register int x, register int y, int oldx, int oldy,
GravityTranslate (int x, int y, int oldx, int oldy,
int dw, int dh, unsigned gravity,
register int *destx, register int *desty)
int *destx, int *desty)
{
switch (gravity) {
case NorthGravity:
@ -1805,10 +1821,10 @@ GravityTranslate (register int x, register int y, int oldx, int oldy,
/* XXX need to retile border on each window with ParentRelative origin */
_X_EXPORT void
ResizeChildrenWinSize(register WindowPtr pWin, int dx, int dy, int dw, int dh)
ResizeChildrenWinSize(WindowPtr pWin, int dx, int dy, int dw, int dh)
{
register ScreenPtr pScreen;
register WindowPtr pSib, pChild;
ScreenPtr pScreen;
WindowPtr pSib, pChild;
Bool resized = (dw || dh);
pScreen = pWin->drawable.pScreen;
@ -1900,10 +1916,10 @@ ResizeChildrenWinSize(register WindowPtr pWin, int dx, int dy, int dw, int dh)
static int
IsSiblingAboveMe(
register WindowPtr pMe,
register WindowPtr pSib)
WindowPtr pMe,
WindowPtr pSib)
{
register WindowPtr pWin;
WindowPtr pWin;
pWin = pMe->parent->firstChild;
while (pWin)
@ -1919,8 +1935,8 @@ IsSiblingAboveMe(
static BoxPtr
WindowExtents(
register WindowPtr pWin,
register BoxPtr pBox)
WindowPtr pWin,
BoxPtr pBox)
{
pBox->x1 = pWin->drawable.x - wBorderWidth (pWin);
pBox->y1 = pWin->drawable.y - wBorderWidth (pWin);
@ -1936,7 +1952,7 @@ WindowExtents(
static RegionPtr
MakeBoundingRegion (
register WindowPtr pWin,
WindowPtr pWin,
BoxPtr pBox)
{
RegionPtr pRgn;
@ -1962,7 +1978,7 @@ ShapeOverlap (
BoxPtr pSibBox)
{
RegionPtr pWinRgn, pSibRgn;
register ScreenPtr pScreen;
ScreenPtr pScreen;
Bool ret;
if (!IS_SHAPED(pWin) && !IS_SHAPED(pSib))
@ -1982,11 +1998,11 @@ static Bool
AnyWindowOverlapsMe(
WindowPtr pWin,
WindowPtr pHead,
register BoxPtr box)
BoxPtr box)
{
register WindowPtr pSib;
WindowPtr pSib;
BoxRec sboxrec;
register BoxPtr sbox;
BoxPtr sbox;
for (pSib = pWin->prevSib; pSib != pHead; pSib = pSib->prevSib)
{
@ -2007,11 +2023,11 @@ AnyWindowOverlapsMe(
static Bool
IOverlapAnyWindow(
WindowPtr pWin,
register BoxPtr box)
BoxPtr box)
{
register WindowPtr pSib;
WindowPtr pSib;
BoxRec sboxrec;
register BoxPtr sbox;
BoxPtr sbox;
for (pSib = pWin->nextSib; pSib; pSib = pSib->nextSib)
{
@ -2059,8 +2075,8 @@ IOverlapAnyWindow(
static WindowPtr
WhereDoIGoInTheStack(
register WindowPtr pWin,
register WindowPtr pSib,
WindowPtr pWin,
WindowPtr pSib,
short x,
short y,
unsigned short w,
@ -2068,7 +2084,7 @@ WhereDoIGoInTheStack(
int smode)
{
BoxRec box;
register ScreenPtr pScreen;
ScreenPtr pScreen;
WindowPtr pHead, pFirst;
if ((pWin == pWin->parent->firstChild) &&
@ -2165,8 +2181,8 @@ WhereDoIGoInTheStack(
static void
ReflectStackChange(
register WindowPtr pWin,
register WindowPtr pSib,
WindowPtr pWin,
WindowPtr pSib,
VTKind kind)
{
/* Note that pSib might be NULL */
@ -2218,17 +2234,17 @@ ReflectStackChange(
*****/
int
ConfigureWindow(register WindowPtr pWin, register Mask mask, XID *vlist, ClientPtr client)
ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
{
#define RESTACK_WIN 0
#define MOVE_WIN 1
#define RESIZE_WIN 2
#define REBORDER_WIN 3
register WindowPtr pSib = NullWindow;
register WindowPtr pParent = pWin->parent;
WindowPtr pSib = NullWindow;
WindowPtr pParent = pWin->parent;
Window sibwid = 0;
Mask index2, tmask;
register XID *pVlist;
XID *pVlist;
short x, y, beforeX, beforeY;
unsigned short w = pWin->drawable.width,
h = pWin->drawable.height,
@ -2505,7 +2521,7 @@ ActuallyDoSomething:
int
CirculateWindow(WindowPtr pParent, int direction, ClientPtr client)
{
register WindowPtr pWin, pHead, pFirst;
WindowPtr pWin, pHead, pFirst;
xEvent event;
BoxRec box;
@ -2575,14 +2591,14 @@ CompareWIDs(
*****/
int
ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
ReparentWindow(WindowPtr pWin, WindowPtr pParent,
int x, int y, ClientPtr client)
{
WindowPtr pPrev, pPriorParent;
Bool WasMapped = (Bool)(pWin->mapped);
xEvent event;
int bw = wBorderWidth (pWin);
register ScreenPtr pScreen;
ScreenPtr pScreen;
pScreen = pWin->drawable.pScreen;
if (TraverseTree(pWin, CompareWIDs, (pointer)&pParent->drawable.id) == WT_STOPWALKING)
@ -2669,7 +2685,7 @@ ReparentWindow(register WindowPtr pWin, register WindowPtr pParent,
static void
RealizeTree(WindowPtr pWin)
{
register WindowPtr pChild;
WindowPtr pChild;
RealizeWindowProcPtr Realize;
Realize = pWin->drawable.pScreen->RealizeWindow;
@ -2699,6 +2715,30 @@ RealizeTree(WindowPtr pWin)
}
}
static WindowPtr windowDisableMapUnmapEvents;
void
DisableMapUnmapEvents(WindowPtr pWin)
{
assert (windowDisableMapUnmapEvents == NULL);
windowDisableMapUnmapEvents = pWin;
}
void
EnableMapUnmapEvents(WindowPtr pWin)
{
assert (windowDisableMapUnmapEvents != NULL);
windowDisableMapUnmapEvents = NULL;
}
static Bool
MapUnmapEventsEnabled(WindowPtr pWin)
{
return pWin != windowDisableMapUnmapEvents;
}
/*****
* MapWindow
* If some other client has selected SubStructureReDirect on the parent
@ -2708,11 +2748,11 @@ RealizeTree(WindowPtr pWin)
*****/
_X_EXPORT int
MapWindow(register WindowPtr pWin, ClientPtr client)
MapWindow(WindowPtr pWin, ClientPtr client)
{
register ScreenPtr pScreen;
ScreenPtr pScreen;
register WindowPtr pParent;
WindowPtr pParent;
#ifdef DO_SAVE_UNDERS
Bool dosave = FALSE;
#endif
@ -2828,18 +2868,18 @@ MapWindow(register WindowPtr pWin, ClientPtr client)
*****/
void
MapSubwindows(register WindowPtr pParent, ClientPtr client)
MapSubwindows(WindowPtr pParent, ClientPtr client)
{
register WindowPtr pWin;
WindowPtr pFirstMapped = NullWindow;
WindowPtr pWin;
WindowPtr pFirstMapped = NullWindow;
#ifdef DO_SAVE_UNDERS
WindowPtr pFirstSaveUndered = NullWindow;
WindowPtr pFirstSaveUndered = NullWindow;
#endif
register ScreenPtr pScreen;
register Mask parentRedirect;
register Mask parentNotify;
xEvent event;
Bool anyMarked;
ScreenPtr pScreen;
Mask parentRedirect;
Mask parentNotify;
xEvent event;
Bool anyMarked;
#ifdef DO_SAVE_UNDERS
Bool dosave = FALSE;
#endif
@ -2948,7 +2988,7 @@ UnrealizeTree(
WindowPtr pWin,
Bool fromConfigure)
{
register WindowPtr pChild;
WindowPtr pChild;
UnrealizeWindowProcPtr Unrealize;
MarkUnrealizedWindowProcPtr MarkUnrealizedWindow;
@ -3007,9 +3047,9 @@ UnrealizeTree(
*****/
_X_EXPORT int
UnmapWindow(register WindowPtr pWin, Bool fromConfigure)
UnmapWindow(WindowPtr pWin, Bool fromConfigure)
{
register WindowPtr pParent;
WindowPtr pParent;
xEvent event;
Bool wasRealized = (Bool)pWin->realized;
Bool wasViewable = (Bool)pWin->viewable;
@ -3066,9 +3106,9 @@ UnmapWindow(register WindowPtr pWin, Bool fromConfigure)
*****/
void
UnmapSubwindows(register WindowPtr pWin)
UnmapSubwindows(WindowPtr pWin)
{
register WindowPtr pChild, pHead;
WindowPtr pChild, pHead;
xEvent event;
Bool wasRealized = (Bool)pWin->realized;
Bool wasViewable = (Bool)pWin->viewable;
@ -3157,10 +3197,10 @@ UnmapSubwindows(register WindowPtr pWin)
void
HandleSaveSet(register ClientPtr client)
HandleSaveSet(ClientPtr client)
{
register WindowPtr pParent, pWin;
register int j;
WindowPtr pParent, pWin;
int j;
for (j=0; j<client->numSaved; j++)
{
@ -3197,27 +3237,12 @@ HandleSaveSet(register ClientPtr client)
client->saveSet = (SaveSetElt *)NULL;
}
/**
*
* \param x,y in root
* \param box "return" value
*/
Bool
VisibleBoundingBoxFromPoint(register WindowPtr pWin, int x, int y, BoxPtr box)
{
if (!pWin->realized)
return (FALSE);
if (POINT_IN_REGION(pWin->drawable.pScreen, &pWin->clipList, x, y, box))
return(TRUE);
return(FALSE);
}
/**
*
* \param x,y in root
*/
Bool
PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
PointInWindowIsVisible(WindowPtr pWin, int x, int y)
{
BoxRec box;
@ -3236,9 +3261,9 @@ PointInWindowIsVisible(register WindowPtr pWin, int x, int y)
_X_EXPORT RegionPtr
NotClippedByChildren(register WindowPtr pWin)
NotClippedByChildren(WindowPtr pWin)
{
register ScreenPtr pScreen;
ScreenPtr pScreen;
RegionPtr pReg;
pScreen = pWin->drawable.pScreen;
@ -3320,30 +3345,6 @@ SendVisibilityNotify(WindowPtr pWin)
DeliverEvents(pWin, &event, 1, NullWindow);
}
static WindowPtr windowDisableMapUnmapEvents;
void
DisableMapUnmapEvents(WindowPtr pWin)
{
assert (windowDisableMapUnmapEvents == NULL);
windowDisableMapUnmapEvents = pWin;
}
void
EnableMapUnmapEvents(WindowPtr pWin)
{
assert (windowDisableMapUnmapEvents != NULL);
windowDisableMapUnmapEvents = NULL;
}
Bool
MapUnmapEventsEnabled(WindowPtr pWin)
{
return pWin != windowDisableMapUnmapEvents;
}
#define RANDOM_WIDTH 32
#ifndef NOLOGOHACK
@ -3584,7 +3585,7 @@ TileScreenSaver(int i, int kind)
*/
_X_EXPORT WindowPtr
FindWindowWithOptional (register WindowPtr w)
FindWindowWithOptional (WindowPtr w)
{
do
w = w->parent;
@ -3601,10 +3602,10 @@ FindWindowWithOptional (register WindowPtr w)
*/
_X_EXPORT void
CheckWindowOptionalNeed (register WindowPtr w)
CheckWindowOptionalNeed (WindowPtr w)
{
register WindowOptPtr optional;
register WindowOptPtr parentOptional;
WindowOptPtr optional;
WindowOptPtr parentOptional;
if (!w->parent)
return;
@ -3655,10 +3656,10 @@ CheckWindowOptionalNeed (register WindowPtr w)
*/
_X_EXPORT Bool
MakeWindowOptional (register WindowPtr pWin)
MakeWindowOptional (WindowPtr pWin)
{
register WindowOptPtr optional;
register WindowOptPtr parentOptional;
WindowOptPtr optional;
WindowOptPtr parentOptional;
if (pWin->optional)
return TRUE;
@ -3696,41 +3697,6 @@ MakeWindowOptional (register WindowPtr pWin)
return TRUE;
}
void
DisposeWindowOptional (register WindowPtr pWin)
{
if (!pWin->optional)
return;
/*
* everything is peachy. Delete the optional record
* and clean up
*/
/*
* TOG changed this code to:
*
* if (pWin->cursorIsNone == FALSE)
* FreeCursor (pWin->optional->cursor, (Cursor)0);
* pWin->cursorIsNone = TRUE;
*
* This is blatently wrong; windows without optionals can have
* two different cursor values, either None or sharing their
* parents cursor. This difference is controlled by the
* cursorIsNone value; when TRUE, the window has no cursor,
* when false, it shares its cursor with its parent; TOG
* made it impossible for a window to have a cursor without
* an optional record.
*/
if (pWin->optional->cursor)
{
FreeCursor (pWin->optional->cursor, (Cursor)0);
pWin->cursorIsNone = FALSE;
}
else
pWin->cursorIsNone = TRUE;
xfree (pWin->optional);
pWin->optional = NULL;
}
#ifndef NOLOGOHACK
static void
DrawLogo(WindowPtr pWin)

4
hw/dmx/dmxclient.h
View File

@ -126,7 +126,7 @@ typedef XID KeySym64;
#undef KeySym
#endif
/* These are in exglobals.h, but that conflicts with X11/extensions/XKBsrv.h */
/* These are in exglobals.h, but that conflicts with xkbsrv.h */
extern int ProximityIn;
extern int ProximityOut;
extern int DeviceValuator;
@ -144,7 +144,7 @@ extern int ChangeDeviceNotify;
#ifndef XKB_IN_SERVER
#define XKB_IN_SERVER
#endif
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#undef XPointer
#endif
#include <X11/extensions/XIproto.h>

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

@ -42,7 +42,7 @@
#endif
#ifdef XKB
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#endif
#include <X11/extensions/XI.h>

1
hw/xfree86/Makefile.am
View File

@ -56,6 +56,7 @@ XORG_LIBS = \
parser/libxf86config.a \
dixmods/libdixmods.la \
modes/libxf86modes.a \
ramdac/libramdac.a \
ddc/libddc.a \
i2c/libi2c.a \
@XORG_LIBS@

31
hw/xfree86/common/xf86Bus.c
View File

@ -1791,6 +1791,15 @@ convertRange2Host(int entityIndex, resRange *pRange)
}
}
static void
xf86ConvertListToHost(int entityIndex, resPtr list)
{
while (list) {
convertRange2Host(entityIndex, &list->val);
list = list->next;
}
}
/*
* xf86RegisterResources() -- attempts to register listed resources.
* If list is NULL it tries to obtain resources implicitly. Function
@ -2836,18 +2845,7 @@ xf86IsSubsetOf(resRange range, resPtr list)
return ret;
}
Bool
xf86IsListSubsetOf(resPtr list, resPtr BaseList)
{
while (list) {
if (! xf86IsSubsetOf(list->val,BaseList))
return FALSE;
list = list->next;
}
return TRUE;
}
resPtr
static resPtr
findIntersect(resRange Range, resPtr list)
{
resRange range;
@ -3071,15 +3069,6 @@ xf86NoSharedResources(int screenIndex,resType res)
return TRUE;
}
void
xf86ConvertListToHost(int entityIndex, resPtr list)
{
while (list) {
convertRange2Host(entityIndex, &list->val);
list = list->next;
}
}
_X_EXPORT void
xf86RegisterStateChangeNotificationCallback(xf86StateChangeNotificationCallbackFunc func, pointer arg)
{

3
hw/xfree86/common/xf86Bus.h
View File

@ -141,12 +141,9 @@ int xf86AllocateEntity(void);
BusType StringToBusType(const char* busID, const char **retID);
memType ChkConflict(resRange *rgp, resPtr res, xf86State state);
Bool xf86IsSubsetOf(resRange range, resPtr list);
Bool xf86IsListSubsetOf(resPtr list, resPtr BaseList);
resPtr xf86ExtractTypeFromList(resPtr list, unsigned long type);
resPtr findIntersect(resRange Range, resPtr list);
resPtr xf86FindIntersect(resRange Range, resPtr list);
void RemoveOverlaps(resPtr target, resPtr list, Bool pow2Alignment,
Bool useEstimated);
void xf86ConvertListToHost(int entityIndex, resPtr list);
#endif /* _XF86_BUS_H */

30
hw/xfree86/common/xf86Config.c
View File

@ -75,7 +75,7 @@ extern DeviceAssocRec mouse_assoc;
#ifdef XKB
#undef XKB_IN_SERVER
#define XKB_IN_SERVER
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#endif
#ifdef RENDER
@ -538,25 +538,6 @@ xf86DriverlistFromCompile(void)
return driverlist;
}
char **
xf86InputDriverlistFromCompile(void)
{
static char **driverlist = NULL;
static Bool generated = FALSE;
/* This string is modified in-place */
static char drivernames[] = IDRIVERS;
if (!generated) {
generated = TRUE;
driverlist = GenerateDriverlist("input", drivernames);
}
return driverlist;
}
/*
* xf86ConfigError --
* Print a READABLE ErrorMessage!!! All information that is
@ -2504,17 +2485,8 @@ xf86HandleConfigFile(Bool autoconfig)
return CONFIG_OK;
}
/* These make the equivalent parser functions visible to the common layer. */
Bool
xf86PathIsAbsolute(const char *path)
{
return (xf86pathIsAbsolute(path) != 0);
}
Bool
xf86PathIsSafe(const char *path)
{
return (xf86pathIsSafe(path) != 0);
}

1
hw/xfree86/common/xf86Config.h
View File

@ -53,7 +53,6 @@ char ** xf86ModulelistFromConfig(pointer **);
char ** xf86DriverlistFromConfig(void);
char ** xf86DriverlistFromCompile(void);
char ** xf86InputDriverlistFromConfig(void);
char ** xf86InputDriverlistFromCompile(void);
Bool xf86BuiltinInputDriver(const char *);
ConfigStatus xf86HandleConfigFile(Bool);

2
hw/xfree86/common/xf86Configure.c
View File

@ -68,7 +68,7 @@ static int nDevToConfig = 0, CurrentDriver;
_X_EXPORT xf86MonPtr ConfiguredMonitor;
Bool xf86DoConfigurePass1 = TRUE;
Bool foundMouse = FALSE;
static Bool foundMouse = FALSE;
#if defined(__UNIXOS2__)
#define DFLT_MOUSE_DEV "mouse$"

182
hw/xfree86/common/xf86DGA.c
View File

@ -43,7 +43,7 @@
#include "servermd.h"
#include "micmap.h"
#ifdef XKB
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#endif
#include "xf86Xinput.h"
@ -51,11 +51,14 @@
static unsigned long DGAGeneration = 0;
static int DGAScreenIndex = -1;
static int mieq_installed = 0;
static Bool DGACloseScreen(int i, ScreenPtr pScreen);
static void DGADestroyColormap(ColormapPtr pmap);
static void DGAInstallColormap(ColormapPtr pmap);
static void DGAUninstallColormap(ColormapPtr pmap);
static void DGAHandleEvent(int screen_num, xEvent *event,
DeviceIntPtr device, int nevents);
static void
DGACopyModeInfo(
@ -96,7 +99,6 @@ typedef struct {
Bool grabKeyboard;
} DGAScreenRec, *DGAScreenPtr;
_X_EXPORT Bool
DGAInit(
ScreenPtr pScreen,
@ -146,7 +148,6 @@ DGAInit(
modes[i].flags &= ~DGA_PIXMAP_AVAILABLE;
#endif
pScreen->devPrivates[DGAScreenIndex].ptr = (pointer)pScreenPriv;
pScreenPriv->CloseScreen = pScreen->CloseScreen;
pScreen->CloseScreen = DGACloseScreen;
@ -157,11 +158,6 @@ DGAInit(
pScreenPriv->UninstallColormap = pScreen->UninstallColormap;
pScreen->UninstallColormap = DGAUninstallColormap;
/*
* This is now set in InitOutput().
*
pScrn->SetDGAMode = xf86SetDGAMode;
*/
return TRUE;
}
@ -247,12 +243,22 @@ FreeMarkedVisuals(ScreenPtr pScreen)
}
}
static Bool
DGACloseScreen(int i, ScreenPtr pScreen)
{
DGAScreenPtr pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
if (XDGAEventBase) {
OsBlockSignals();
ProcessInputEvents();
mieqSetHandler(*XDGAEventBase + MotionNotify, NULL);
mieqSetHandler(*XDGAEventBase + ButtonPress, NULL);
mieqSetHandler(*XDGAEventBase + ButtonRelease, NULL);
mieqSetHandler(*XDGAEventBase + KeyPress, NULL);
mieqSetHandler(*XDGAEventBase + KeyRelease, NULL);
OsReleaseSignals();
}
FreeMarkedVisuals(pScreen);
pScreen->CloseScreen = pScreenPriv->CloseScreen;
@ -462,6 +468,15 @@ DGASetInputMode(int index, Bool keyboard, Bool mouse)
{
pScreenPriv->grabMouse = mouse;
pScreenPriv->grabKeyboard = keyboard;
if (!mieq_installed) {
mieqSetHandler(*XDGAEventBase + MotionNotify, DGAHandleEvent);
mieqSetHandler(*XDGAEventBase + ButtonPress, DGAHandleEvent);
mieqSetHandler(*XDGAEventBase + ButtonRelease, DGAHandleEvent);
mieqSetHandler(*XDGAEventBase + KeyPress, DGAHandleEvent);
mieqSetHandler(*XDGAEventBase + KeyRelease, DGAHandleEvent);
mieq_installed = 1;
}
}
}
@ -903,21 +918,93 @@ DGAVTSwitch(void)
return TRUE;
}
/* We have the power to steal or modify events that are about to get queued */
Bool
DGAStealKeyEvent(int index, xEvent *e)
DGAStealKeyEvent(int index, int key_code, int is_down)
{
}
DGAScreenPtr pScreenPriv;
dgaEvent de;
if(DGAScreenIndex < 0) /* no DGA */
return FALSE;
pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);
if(!pScreenPriv || !pScreenPriv->grabKeyboard) /* no direct mode */
return FALSE;
de.u.u.type = *XDGAEventBase + (is_down ? KeyPress : KeyRelease);
de.u.u.detail = key_code;
de.u.event.time = GetTimeInMillis();
mieqEnqueue (inputInfo.keyboard, (xEvent *) &de);
return TRUE;
}
static int DGAMouseX, DGAMouseY;
Bool
DGAStealMouseEvent(int index, xEvent *e, int dx, int dy)
DGAStealMotionEvent(int index, int dx, int dy)
{
DGAScreenPtr pScreenPriv;
dgaEvent de;
if(DGAScreenIndex < 0) /* no DGA */
return FALSE;
pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);
if(!pScreenPriv || !pScreenPriv->grabMouse) /* no direct mode */
return FALSE;
DGAMouseX += dx;
if (DGAMouseX < 0)
DGAMouseX = 0;
else if (DGAMouseX > screenInfo.screens[index]->width)
DGAMouseX = screenInfo.screens[index]->width;
DGAMouseY += dy;
if (DGAMouseY < 0)
DGAMouseY = 0;
else if (DGAMouseY > screenInfo.screens[index]->height)
DGAMouseY = screenInfo.screens[index]->height;
de.u.u.type = *XDGAEventBase + MotionNotify;
de.u.u.detail = 0;
de.u.event.time = GetTimeInMillis();
de.u.event.dx = dx;
de.u.event.dy = dy;
de.u.event.pad1 = DGAMouseX;
de.u.event.pad2 = DGAMouseY;
mieqEnqueue (inputInfo.pointer, (xEvent *) &de);
return TRUE;
}
Bool
DGAStealButtonEvent(int index, int button, int is_down)
{
DGAScreenPtr pScreenPriv;
dgaEvent de;
if (DGAScreenIndex < 0)
return FALSE;
pScreenPriv = DGA_GET_SCREEN_PRIV(screenInfo.screens[index]);
if (!pScreenPriv || !pScreenPriv->grabMouse)
return FALSE;
de.u.u.type = *XDGAEventBase + (is_down ? ButtonPress : ButtonRelease);
de.u.u.detail = button;
de.u.event.time = GetTimeInMillis();
de.u.event.dx = 0;
de.u.event.dy = 0;
de.u.event.pad1 = DGAMouseX;
de.u.event.pad2 = DGAMouseY;
mieqEnqueue (inputInfo.pointer, (xEvent *) &de);
return TRUE;
}
/* We have the power to steal or modify events that are about to get queued */
Bool
DGAIsDgaEvent (xEvent *e)
{
@ -1124,39 +1211,6 @@ DGAProcessPointerEvent (ScreenPtr pScreen, dgaEvent *de, DeviceIntPtr mouse)
}
}
Bool
DGADeliverEvent (ScreenPtr pScreen, xEvent *e)
{
dgaEvent *de = (dgaEvent *) e;
DGAScreenPtr pScreenPriv;
int coreEquiv;
/* no DGA */
if (DGAScreenIndex < 0 || XDGAEventBase == 0)
return FALSE;
pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
/* DGA not initialized on this screen */
if (!pScreenPriv)
return FALSE;
coreEquiv = de->u.u.type - *XDGAEventBase;
/* Not a DGA event */
if (coreEquiv < KeyPress || coreEquiv > MotionNotify)
return FALSE;
switch (coreEquiv) {
case KeyPress:
case KeyRelease:
DGAProcessKeyboardEvent (pScreen, de, inputInfo.keyboard);
break;
default:
DGAProcessPointerEvent (pScreen, de, inputInfo.pointer);
break;
}
return TRUE;
}
_X_EXPORT Bool
DGAOpenFramebuffer(
int index,
@ -1215,3 +1269,35 @@ DGAGetOldDGAMode(int index)
return 0;
}
static void
DGAHandleEvent(int screen_num, xEvent *event, DeviceIntPtr device, int nevents)
{
dgaEvent *de = (dgaEvent *) event;
ScreenPtr pScreen = screenInfo.screens[screen_num];
DGAScreenPtr pScreenPriv;
int coreEquiv;
/* no DGA */
if (DGAScreenIndex < 0 || XDGAEventBase == 0)
return;
pScreenPriv = DGA_GET_SCREEN_PRIV(pScreen);
/* DGA not initialized on this screen */
if (!pScreenPriv)
return;
coreEquiv = de->u.u.type - *XDGAEventBase;
/* Not a DGA event; shouldn't happen, but you never know. */
if (coreEquiv < KeyPress || coreEquiv > MotionNotify)
return;
switch (coreEquiv) {
case KeyPress:
case KeyRelease:
DGAProcessKeyboardEvent (pScreen, de, inputInfo.keyboard);
break;
default:
DGAProcessPointerEvent (pScreen, de, inputInfo.pointer);
break;
}
}

4
hw/xfree86/common/xf86Events.c
View File

@ -126,9 +126,9 @@ extern Bool noXkbExtension;
*/
#ifdef USE_VT_SYSREQ
Bool VTSysreqToggle = FALSE;
static Bool VTSysreqToggle = FALSE;
#endif /* !USE_VT_SYSREQ */
Bool VTSwitchEnabled = TRUE; /* Allows run-time disabling for
_X_EXPORT Bool VTSwitchEnabled = TRUE; /* Allows run-time disabling for
*BSD and for avoiding VT
switches when using the DRI
automatic full screen mode.*/

1
hw/xfree86/common/xf86Globals.c
View File

@ -146,7 +146,6 @@ _X_EXPORT confDRIRec xf86ConfigDRI = {0, };
XF86ConfigPtr xf86configptr = NULL;
Bool xf86Resetting = FALSE;
Bool xf86Initialising = FALSE;
Bool xf86ProbeFailed = FALSE;
Bool xf86DoProbe = FALSE;
Bool xf86DoConfigure = FALSE;
DriverPtr *xf86DriverList = NULL;

13
hw/xfree86/common/xf86Helper.c
View File

@ -2981,3 +2981,16 @@ xf86IsUnblank(int mode)
return TRUE;
}
}
_X_EXPORT void
xf86MotionHistoryAllocate(LocalDevicePtr local)
{
AllocateMotionHistory(local->dev);
}
_X_EXPORT int
xf86GetMotionEvents(DeviceIntPtr pDev, xTimecoord *buff, unsigned long start,
unsigned long stop, ScreenPtr pScreen)
{
return GetMotionHistory(pDev, buff, start, stop, pScreen);
}

2
hw/xfree86/common/xf86Priv.h
View File

@ -100,7 +100,6 @@ extern int xf86NumModuleInfos;
extern int xf86NumDrivers;
extern Bool xf86Resetting;
extern Bool xf86Initialising;
extern Bool xf86ProbeFailed;
extern int xf86NumScreens;
extern pciVideoPtr *xf86PciVideoInfo;
extern xf86CurrentAccessRec xf86CurrentAccess;
@ -155,7 +154,6 @@ extern int pciTestMultiDeviceCard(int bus, int dev, int func, PCITAG** pTag);
/* xf86Config.c */
Bool xf86PathIsAbsolute(const char *path);
Bool xf86PathIsSafe(const char *path);
/* xf86DefaultModes */

2
hw/xfree86/common/xf86XKB.c
View File

@ -73,7 +73,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#define XF86_OS_PRIVS
#include "xf86_OSlib.h"
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
void
xf86InitXkb(void)

46
hw/xfree86/common/xf86Xinput.c
View File

@ -90,6 +90,10 @@
#include "mi.h"
#ifdef XFreeXDGA
#include "dgaproc.h"
#endif
xEvent *xf86Events = NULL;
static Bool
@ -128,6 +132,9 @@ xf86ProcessCommonOptions(LocalDevicePtr local,
} else {
xf86Msg(X_CONFIG, "%s: doesn't report drag events\n", local->name);
}
/* Backwards compatibility. */
local->history_size = GetMotionHistorySize();
}
/***********************************************************************
@ -395,10 +402,12 @@ xf86PostMotionEvent(DeviceIntPtr device,
{
va_list var;
int i = 0, nevents = 0;
int dx, dy;
Bool drag = xf86SendDragEvents(device);
int *valuators = NULL;
int flags = 0;
xEvent *xE = NULL;
int index;
if (is_absolute)
flags = POINTER_ABSOLUTE;
@ -412,6 +421,24 @@ xf86PostMotionEvent(DeviceIntPtr device,
valuators[i] = va_arg(var, int);
va_end(var);
#if XFreeXDGA
if (first_valuator == 0 && num_valuators >= 2) {
if (miPointerGetScreen(inputInfo.pointer)) {
index = miPointerGetScreen(inputInfo.pointer)->myNum;
if (is_absolute) {
dx = valuators[0] - device->valuator->lastx;
dy = valuators[1] - device->valuator->lasty;
}
else {
dx = valuators[0];
dy = valuators[1];
}
if (DGAStealMotionEvent(index, dx, dy))
goto out;
}
}
#endif
if (!xf86Events)
xf86Events = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());
if (!xf86Events)
@ -430,6 +457,7 @@ xf86PostMotionEvent(DeviceIntPtr device,
}
}
out:
xfree(valuators);
}
@ -476,6 +504,15 @@ xf86PostButtonEvent(DeviceIntPtr device,
va_list var;
int *valuators = NULL;
int i = 0, nevents = 0;
int index;
#if XFreeXDGA
if (miPointerGetScreen(inputInfo.pointer)) {
index = miPointerGetScreen(inputInfo.pointer)->myNum;
if (DGAStealButtonEvent(index, button, is_down))
return;
}
#endif
valuators = xcalloc(sizeof(int), num_valuators);
@ -552,6 +589,15 @@ xf86PostKeyboardEvent(DeviceIntPtr device,
int is_down)
{
int nevents = 0, i = 0;
int index;
#if XFreeXDGA
if (miPointerGetScreen(inputInfo.pointer)) {
index = miPointerGetScreen(inputInfo.pointer)->myNum;
if (DGAStealKeyEvent(index, key_code, is_down))
return;
}
#endif
if (!xf86Events)
xf86Events = (xEvent *)xcalloc(sizeof(xEvent), GetMaximumEventsNum());

8
hw/xfree86/common/xf86Xinput.h
View File

@ -86,6 +86,9 @@
#define XI_PRIVATE(dev) \
(((LocalDevicePtr)((dev)->public.devicePrivate))->private)
/* Stupid API backwards-compatibility. */
#define TS_Raw 60
#define TS_Scaled 61
#ifdef XINPUT
/* This holds the input driver entry and module information. */
@ -144,6 +147,7 @@ typedef struct _LocalDeviceRec {
InputDriverPtr drv;
pointer module;
pointer options;
unsigned int history_size;
} LocalDeviceRec, *LocalDevicePtr, InputInfoRec, *InputInfoPtr;
typedef struct _DeviceAssocRec
@ -191,6 +195,10 @@ InputInfoPtr xf86AllocateInput(InputDriverPtr drv, int flags);
InputDriverPtr xf86LookupInputDriver(const char *name);
InputInfoPtr xf86LookupInput(const char *name);
void xf86DeleteInput(InputInfoPtr pInp, int flags);
void xf86MotionHistoryAllocate(LocalDevicePtr local);
int xf86GetMotionEvents(DeviceIntPtr dev, xTimecoord *buff,
unsigned long start, unsigned long stop,
ScreenPtr pScreen);
/* xf86Option.c */
void xf86CollectInputOptions(InputInfoPtr pInfo, const char **defaultOpts,

2
hw/xfree86/common/xf86xv.c
View File

@ -110,7 +110,7 @@ static void xf86XVAdjustFrame(int index, int x, int y, int flags);
static Bool xf86XVInitAdaptors(ScreenPtr, XF86VideoAdaptorPtr*, int);
int XF86XVWindowIndex = -1;
static int XF86XVWindowIndex = -1;
int XF86XvScreenIndex = -1;
static unsigned long XF86XVGeneration = 0;
static unsigned long PortResource = 0;

53
hw/xfree86/ddc/xf86DDC.c
View File

@ -15,52 +15,6 @@
static const OptionInfoRec *DDCAvailableOptions(void *unused);
#if DDC_MODULE
static MODULESETUPPROTO(ddcSetup);
static XF86ModuleVersionInfo ddcVersRec =
{
"ddc",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XORG_VERSION_CURRENT,
1, 0, 0,
ABI_CLASS_VIDEODRV, /* needs the video driver ABI */
ABI_VIDEODRV_VERSION,
MOD_CLASS_NONE,
{0,0,0,0}
};
_X_EXPORT XF86ModuleData ddcModuleData = { &ddcVersRec, ddcSetup, NULL };
ModuleInfoRec DDC = {
1,
"DDC",
NULL,
0,
DDCAvailableOptions,
};
static pointer
ddcSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
static Bool setupDone = FALSE;
if (!setupDone) {
setupDone = TRUE;
xf86AddModuleInfo(&DDC, module);
}
/*
* The return value must be non-NULL on success even though there
* is no TearDownProc.
*/
return (pointer)1;
}
#endif
#define RETRIES 4
static unsigned char *EDIDRead_DDC1(
@ -337,6 +291,12 @@ DDCRead_DDC2(int scrnIndex, I2CBusPtr pBus, int start, int len)
unsigned char *R_Buffer;
int i;
/*
* Slow down the bus so that older monitors don't
* miss things.
*/
pBus->RiseFallTime = 20;
if (!(dev = xf86I2CFindDev(pBus, 0x00A0))) {
dev = xf86CreateI2CDevRec();
dev->DevName = "ddc2";
@ -344,7 +304,6 @@ DDCRead_DDC2(int scrnIndex, I2CBusPtr pBus, int start, int len)
dev->ByteTimeout = 2200; /* VESA DDC spec 3 p. 43 (+10 %) */
dev->StartTimeout = 550;
dev->BitTimeout = 40;
dev->ByteTimeout = 40;
dev->AcknTimeout = 40;
dev->pI2CBus = pBus;

5
hw/xfree86/dixmods/extmod/dgaproc.h
View File

@ -120,8 +120,9 @@ int DGAGetOldDGAMode(int Index);
int DGAGetModeInfo(int Index, XDGAModePtr mode, int num);
Bool DGAVTSwitch(void);
Bool DGAStealMouseEvent(int Index, xEvent *e, int dx, int dy);
Bool DGAStealKeyEvent(int Index, xEvent *e);
Bool DGAStealButtonEvent(int Index, int button, int is_down);
Bool DGAStealMotionEvent(int Index, int dx, int dy);
Bool DGAStealKeyEvent(int Index, int key_code, int is_down);
Bool DGAIsDgaEvent (xEvent *e);
Bool DGADeliverEvent (ScreenPtr pScreen, xEvent *e);

2
hw/xfree86/dixmods/xkbKillSrv.c
View File

@ -40,7 +40,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "inputstr.h"
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#include <X11/extensions/XI.h>
#include "xf86.h"

2
hw/xfree86/dixmods/xkbPrivate.c
View File

@ -12,7 +12,7 @@
#include <X11/X.h>
#include "windowstr.h"
#define XKBSRV_NEED_FILE_FUNCS
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#include "xf86.h"

2
hw/xfree86/dixmods/xkbVT.c
View File

@ -40,7 +40,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "inputstr.h"
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
#include <X11/extensions/XI.h>
#include "xf86.h"

6
hw/xfree86/dri/dri.c
View File

@ -71,6 +71,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "mipointer.h"
#include "xf86_OSproc.h"
#define PCI_BUS_NO_DOMAIN(bus) ((bus) & 0xffu)
#if !defined(PANORAMIX)
extern Bool noPanoramiXExtension;
#endif
@ -2202,8 +2204,8 @@ DRICreatePCIBusID(pciVideoPtr PciInfo)
tag = pciTag(PciInfo->bus, PciInfo->device, PciInfo->func);
domain = xf86GetPciDomain(tag);
snprintf(busID, 20, "pci:%04x:%02x:%02x.%d", domain, PciInfo->bus,
PciInfo->device, PciInfo->func);
snprintf(busID, 20, "pci:%04x:%02x:%02x.%d", domain,
PCI_BUS_NO_DOMAIN(PciInfo->bus), PciInfo->device, PciInfo->func);
return busID;
}

2
hw/xfree86/i2c/uda1380_module.c
View File

@ -12,7 +12,7 @@ static XF86ModuleVersionInfo uda1380VersRec =
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XF86_VERSION_CURRENT,
XORG_VERSION_CURRENT,
1, 0, 0,
ABI_CLASS_VIDEODRV, /* This needs the video driver ABI */
ABI_VIDEODRV_VERSION,

36
hw/xfree86/i2c/xf86i2cmodule.c
View File

@ -1,36 +0,0 @@
/* (c) Itai Nahshon
*
* This code is derived from and inspired by the I2C driver
* from the Linux kernel.
* (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
*/
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "xf86Module.h"
static MODULESETUPPROTO(i2cSetup);
static XF86ModuleVersionInfo i2cVersRec =
{
"i2c",
MODULEVENDORSTRING,
MODINFOSTRING1,
MODINFOSTRING2,
XORG_VERSION_CURRENT,
1, 2, 0,
ABI_CLASS_VIDEODRV, /* This needs the video driver ABI */
ABI_VIDEODRV_VERSION,
MOD_CLASS_NONE,
{0,0,0,0}
};
_X_EXPORT XF86ModuleData i2cModuleData = { &i2cVersRec, i2cSetup, NULL };
static pointer
i2cSetup(pointer module, pointer opts, int *errmaj, int *errmin) {
/* ErrorF("i2cSetup\n"); */
return (pointer)1;
}

3
hw/xfree86/loader/Makefile.am
View File

@ -2,7 +2,8 @@ noinst_LIBRARIES = libloader.a
INCLUDES = $(XORG_INCS) -I$(srcdir)/../parser -I$(srcdir)/../dixmods/extmod \
-I$(srcdir)/../vbe -I$(top_srcdir)/miext/cw -I$(srcdir)/../int10 \
-I$(srcdir)/../ddc -I$(srcdir)/../i2c -I$(srcdir)/../modes
-I$(srcdir)/../ddc -I$(srcdir)/../i2c -I$(srcdir)/../modes \
-I$(srcdir)/../ramdac
#AM_LDFLAGS = -r
AM_CFLAGS = -DIN_LOADER $(DIX_CFLAGS) $(XORG_CFLAGS)

2
hw/xfree86/loader/dixsym.c
View File

@ -87,7 +87,7 @@
#endif
#include "selection.h"
#ifdef XKB
#include <X11/extensions/XKBsrv.h>
#include <xkbsrv.h>
extern int XkbDfltRepeatDelay, XkbDfltRepeatInterval;
#endif

116
hw/xfree86/loader/loader.c
View File

@ -189,101 +189,6 @@ _LoaderListPop(int handle)
return 0;
}
/*
* _LoaderHandleToName() will return the name of the first module with a
* given handle. This requires getting the last module on the LIFO with
* the given handle.
*/
char *
_LoaderHandleToName(int handle)
{
loaderPtr item = listHead;
loaderPtr aritem = NULL;
loaderPtr lastitem = NULL;
if (handle < 0) {
return "(built-in)";
}
while (item) {
if (item->handle == handle) {
if (strchr(item->name, ':') == NULL)
aritem = item;
else
lastitem = item;
}
item = item->next;
}
if (aritem)
return aritem->name;
if (lastitem)
return lastitem->name;
return 0;
}
/*
* _LoaderHandleToCanonicalName() will return the cname of the first module
* with a given handle. This requires getting the last module on the LIFO with
* the given handle.
*/
char *
_LoaderHandleToCanonicalName(int handle)
{
loaderPtr item = listHead;
loaderPtr lastitem = NULL;
if (handle < 0) {
return "(built-in)";
}
while (item) {
if (item->handle == handle) {
lastitem = item;
}
item = item->next;
}
if (lastitem)
return lastitem->cname;
return NULL;
}
/*
* _LoaderModuleToName() will return the name of the first module with a
* given handle. This requires getting the last module on the LIFO with
* the given handle.
*/
char *
_LoaderModuleToName(int module)
{
loaderPtr item = listHead;
loaderPtr aritem = NULL;
loaderPtr lastitem = NULL;
if (module < 0) {
return "(built-in)";
}
while (item) {
if (item->module == module) {
if (strchr(item->name, ':') == NULL)
aritem = item;
else
lastitem = item;
}
item = item->next;
}
if (aritem)
return aritem->name;
if (lastitem)
return lastitem->name;
return 0;
}
/* These four are just ABI stubs */
_X_EXPORT void
LoaderRefSymbols(const char *sym0, ...)
@ -450,35 +355,14 @@ LoaderUnload(int handle)
return 0;
}
void
LoaderDuplicateSymbol(const char *symbol, const int handle)
{
ErrorF("Duplicate symbol %s in %s\n", symbol,
listHead ? listHead->name : "(built-in)");
ErrorF("Also defined in %s\n", _LoaderHandleToName(handle));
FatalError("Module load failure\n");
}
unsigned long LoaderOptions = 0;
void
LoaderResetOptions(void)
{
LoaderOptions = 0;
}
void
LoaderSetOptions(unsigned long opts)
{
LoaderOptions |= opts;
}
void
LoaderClearOptions(unsigned long opts)
{
LoaderOptions &= ~opts;
}
_X_EXPORT int
LoaderGetABIVersion(const char *abiclass)
{

4
hw/xfree86/loader/loaderProcs.h
View File

@ -97,9 +97,6 @@ void LoadFont(FontModule *);
void UnloadModule(ModuleDescPtr);
void UnloadSubModule(ModuleDescPtr);
void UnloadDriver(ModuleDescPtr);
void FreeModuleDesc(ModuleDescPtr mod);
ModuleDescPtr NewModuleDesc(const char *);
ModuleDescPtr AddSibling(ModuleDescPtr head, ModuleDescPtr new);
void LoaderSetPath(const char *path);
void LoaderSortExtensions(void);
@ -108,7 +105,6 @@ unsigned long LoaderGetModuleVersion(ModuleDescPtr mod);
void LoaderResetOptions(void);
void LoaderSetOptions(unsigned long);
void LoaderClearOptions(unsigned long);
/* Options for LoaderSetOptions */
#define LDR_OPT_ABI_MISMATCH_NONFATAL 0x0001

105
hw/xfree86/loader/loadmod.c
View File

@ -745,6 +745,13 @@ CheckVersion(const char *module, XF86ModuleVersionInfo * data,
return TRUE;
}
static ModuleDescPtr
AddSibling(ModuleDescPtr head, ModuleDescPtr new)
{
new->sib = head;
return (new);
}
_X_EXPORT ModuleDescPtr
LoadSubModule(ModuleDescPtr parent, const char *module,
const char **subdirlist, const char **patternlist,
@ -775,35 +782,28 @@ LoadSubModule(ModuleDescPtr parent, const char *module,
return submod;
}
ModuleDescPtr
LoadSubModuleLocal(ModuleDescPtr parent, const char *module,
const char **subdirlist, const char **patternlist,
pointer options, const XF86ModReqInfo * modreq,
int *errmaj, int *errmin)
static ModuleDescPtr
NewModuleDesc(const char *name)
{
ModuleDescPtr submod;
ModuleDescPtr mdp = xalloc(sizeof(ModuleDesc));
xf86MsgVerb(X_INFO, 3, "Loading local sub module \"%s\"\n", module);
if (PathIsAbsolute(module))
{
xf86Msg(X_ERROR,
"LoadSubModule: Absolute module path not permitted: \"%s\"\n",
module);
if (errmaj)
*errmaj = LDR_BADUSAGE;
if (errmin)
*errmin = 0;
return NULL;
if (mdp) {
mdp->child = NULL;
mdp->sib = NULL;
mdp->parent = NULL;
mdp->demand_next = NULL;
mdp->name = xstrdup(name);
mdp->filename = NULL;
mdp->identifier = NULL;
mdp->client_id = 0;
mdp->in_use = 0;
mdp->handle = -1;
mdp->SetupProc = NULL;
mdp->TearDownProc = NULL;
mdp->TearDownData = NULL;
}
submod = doLoadModule(module, NULL, subdirlist, patternlist, options,
modreq, errmaj, errmin, 0);
if (submod && submod != (ModuleDescPtr) 1) {
parent->child = AddSibling(parent->child, submod);
submod->parent = parent;
}
return submod;
return (mdp);
}
_X_EXPORT ModuleDescPtr
@ -841,6 +841,7 @@ DuplicateModule(ModuleDescPtr mod, ModuleDescPtr parent)
static const char *compiled_in_modules[] = {
"ddc",
"i2c",
"ramdac",
NULL
};
@ -861,14 +862,14 @@ doLoadModule(const char *module, const char *path, const char **subdirlist,
PatternPtr patterns = NULL;
int noncanonical = 0;
char *m = NULL;
char **cim;
const char **cim;
xf86MsgVerb(X_INFO, 3, "LoadModule: \"%s\"", module);
for (cim = compiled_in_modules; *cim; cim++)
if (!strcmp (module, *cim))
{
xf86MsgVerb(X_INFO, 3, "Module alread ybuilt-in");
xf86MsgVerb(X_INFO, 3, "Module already built-in\n");
return (ModuleDescPtr) 1;
}
@ -1098,26 +1099,12 @@ LoadModule(const char *module, const char *path, const char **subdirlist,
modreq, errmaj, errmin, LD_FLAG_GLOBAL);
}
ModuleDescPtr
LoadDriver(const char *module, const char *path, int handle, pointer options,
int *errmaj, int *errmin)
{
return LoadModule(module, path, NULL, NULL, options, NULL, errmaj,
errmin);
}
void
UnloadModule(ModuleDescPtr mod)
{
UnloadModuleOrDriver(mod);
}
void
UnloadDriver(ModuleDescPtr mod)
{
UnloadModuleOrDriver(mod);
}
static void
UnloadModuleOrDriver(ModuleDescPtr mod)
{
@ -1167,7 +1154,7 @@ UnloadSubModule(ModuleDescPtr mod)
xfree(mod);
}
void
static void
FreeModuleDesc(ModuleDescPtr head)
{
ModuleDescPtr sibs, prev;
@ -1176,7 +1163,7 @@ FreeModuleDesc(ModuleDescPtr head)
return;
/*
* only free it if it's not marked as in use. In use means that it may
* be unloaded someday, and UnloadModule or UnloadDriver will free it
* be unloaded someday, and UnloadModule will free it
*/
if (head->in_use)
return;
@ -1191,38 +1178,6 @@ FreeModuleDesc(ModuleDescPtr head)
}
}
ModuleDescPtr
NewModuleDesc(const char *name)
{
ModuleDescPtr mdp = xalloc(sizeof(ModuleDesc));
if (mdp) {
mdp->child = NULL;
mdp->sib = NULL;
mdp->parent = NULL;
mdp->demand_next = NULL;
mdp->name = xstrdup(name);
mdp->filename = NULL;
mdp->identifier = NULL;
mdp->client_id = 0;
mdp->in_use = 0;
mdp->handle = -1;
mdp->SetupProc = NULL;
mdp->TearDownProc = NULL;
mdp->TearDownData = NULL;
}
return (mdp);
}
ModuleDescPtr
AddSibling(ModuleDescPtr head, ModuleDescPtr new)
{
new->sib = head;
return (new);
}
static void
RemoveChild(ModuleDescPtr child)
{

6
hw/xfree86/loader/xf86sym.c
View File

@ -1170,6 +1170,7 @@ _X_HIDDEN void *xfree86LookupTab[] = {
SYMVAR(pciNumBuses)
/* modes */
SYMVAR(xf86CrtcConfigPrivateIndex)
SYMFUNC(xf86CrtcConfigInit)
SYMFUNC(xf86CrtcConfigPrivateIndex)
SYMFUNC(xf86CrtcCreate)
@ -1220,6 +1221,11 @@ _X_HIDDEN void *xfree86LookupTab[] = {
SYMFUNC(xf86RandR12SetConfig)
SYMFUNC(xf86RandR12SetRotations)
#endif
SYMFUNC(xf86_cursors_init)
SYMFUNC(xf86_reload_cursors)
SYMFUNC(xf86_show_cursors)
SYMFUNC(xf86_hide_cursors)
SYMFUNC(xf86_cursors_fini)
SYMFUNC(xf86DoEDID_DDC1)
SYMFUNC(xf86DoEDID_DDC2)

4
hw/xfree86/modes/Makefile.am
View File

@ -3,6 +3,7 @@ noinst_LIBRARIES = libxf86modes.a
libxf86modes_a_SOURCES = \
xf86Crtc.c \
xf86Crtc.h \
xf86Cursors.c \
xf86cvt.c \
xf86DiDGA.c \
xf86EdidModes.c \
@ -16,7 +17,8 @@ libxf86modes_a_SOURCES = \
INCLUDES = $(XORG_INCS) -I$(srcdir)/../ddc -I$(srcdir)/../i2c \
-I$(srcdir)/../loader -I$(srcdir)/../rac -I$(srcdir)/../parser \
-I$(srcdir)/../scanpci -I$(srcdir)/../vbe -I$(srcdir)/../int10 \
-I$(srcdir)/../vgahw -I$(srcdir)/../dixmods/extmod
-I$(srcdir)/../vgahw -I$(srcdir)/../ramdac \
-I$(srcdir)/../dixmods/extmod
sdk_HEADERS = \
xf86Crtc.h \

52
hw/xfree86/modes/xf86Crtc.c
View File

@ -312,7 +312,13 @@ xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
{
xf86OutputPtr output = xf86_config->output[i];
if (output->crtc == crtc)
{
output->funcs->commit(output);
#ifdef RANDR_12_INTERFACE
if (output->randr_output)
RRPostPendingProperties (output->randr_output);
#endif
}
}
/* XXX free adjustedmode */
@ -565,6 +571,36 @@ xf86CrtcCreateScreenResources (ScreenPtr screen)
return TRUE;
}
/*
* Clean up config on server reset
*/
static Bool
xf86CrtcCloseScreen (int index, ScreenPtr screen)
{
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(scrn);
int o, c;
screen->CloseScreen = config->CloseScreen;
xf86RotateCloseScreen (screen);
for (o = 0; o < config->num_output; o++)
{
xf86OutputPtr output = config->output[o];
output->crtc = NULL;
output->randr_output = NULL;
}
for (c = 0; c < config->num_crtc; c++)
{
xf86CrtcPtr crtc = config->crtc[c];
crtc->randr_crtc = NULL;
}
return screen->CloseScreen (index, screen);
}
/*
* Called at ScreenInit time to set up
*/
@ -596,6 +632,10 @@ xf86CrtcScreenInit (ScreenPtr screen)
/* Wrap CreateScreenResources so we can initialize the RandR code */
config->CreateScreenResources = screen->CreateScreenResources;
screen->CreateScreenResources = xf86CrtcCreateScreenResources;
config->CloseScreen = screen->CloseScreen;
screen->CloseScreen = xf86CrtcCloseScreen;
return TRUE;
}
@ -1158,7 +1198,10 @@ xf86ProbeOutputModes (ScrnInfoPtr scrn, int maxX, int maxY)
output->status = (*output->funcs->detect)(output);
if (output->status == XF86OutputStatusDisconnected)
{
xf86OutputSetEDID (output, NULL);
continue;
}
memset (&mon_rec, '\0', sizeof (mon_rec));
@ -1552,6 +1595,8 @@ xf86InitialConfiguration (ScrnInfoPtr scrn, Bool canGrow)
{
crtc->desiredMode = *mode;
crtc->desiredRotation = output->initial_rotation;
crtc->desiredX = output->initial_x;
crtc->desiredY = output->initial_y;
crtc->enabled = TRUE;
crtc->x = output->initial_x;
crtc->y = output->initial_y;
@ -1776,7 +1821,12 @@ xf86SetSingleMode (ScrnInfoPtr pScrn, DisplayModePtr desired, Rotation rotation)
if (!xf86CrtcSetMode (crtc, crtc_mode, rotation, 0, 0))
ok = FALSE;
else
{
crtc->desiredMode = *crtc_mode;
crtc->desiredRotation = rotation;
crtc->desiredX = 0;
crtc->desiredY = 0;
}
}
xf86DisableUnusedFunctions(pScrn);
return ok;
@ -1886,7 +1936,7 @@ xf86OutputSetEDIDProperty (xf86OutputPtr output, void *data, int data_len)
if (data_len != 0) {
RRChangeOutputProperty(output->randr_output, edid_atom, XA_INTEGER, 8,
PropModeReplace, data_len, data, FALSE);
PropModeReplace, data_len, data, FALSE, TRUE);
} else {
RRDeleteOutputProperty(output->randr_output, edid_atom);
}

114
hw/xfree86/modes/xf86Crtc.h
View File

@ -28,6 +28,7 @@
#include "xf86Rename.h"
#endif
#include "xf86Modes.h"
#include "xf86Cursor.h"
#include "damage.h"
/* Compat definitions for older X Servers. */
@ -37,6 +38,9 @@
#ifndef M_T_DRIVER
#define M_T_DRIVER 0x40
#endif
#ifndef HARDWARE_CURSOR_ARGB
#define HARDWARE_CURSOR_ARGB 0x00004000
#endif
typedef struct _xf86Crtc xf86CrtcRec, *xf86CrtcPtr;
typedef struct _xf86Output xf86OutputRec, *xf86OutputPtr;
@ -154,6 +158,42 @@ typedef struct _xf86CrtcFuncs {
void
(*shadow_destroy) (xf86CrtcPtr crtc, PixmapPtr pPixmap, void *data);
/**
* Set cursor colors
*/
void
(*set_cursor_colors) (xf86CrtcPtr crtc, int bg, int fg);
/**
* Set cursor position
*/
void
(*set_cursor_position) (xf86CrtcPtr crtc, int x, int y);
/**
* Show cursor
*/
void
(*show_cursor) (xf86CrtcPtr crtc);
/**
* Hide cursor
*/
void
(*hide_cursor) (xf86CrtcPtr crtc);
/**
* Load monochrome image
*/
void
(*load_cursor_image) (xf86CrtcPtr crtc, CARD8 *image);
/**
* Load ARGB image
*/
void
(*load_cursor_argb) (xf86CrtcPtr crtc, CARD32 *image);
/**
* Clean up driver-specific bits of the crtc
*/
@ -174,12 +214,6 @@ struct _xf86Crtc {
*/
Bool enabled;
/** Track whether cursor is within CRTC range */
Bool cursorInRange;
/** Track state of cursor associated with this CRTC */
Bool cursorShown;
/**
* Active mode
*
@ -232,6 +266,19 @@ struct _xf86Crtc {
#else
void *randr_crtc;
#endif
/**
* Current cursor is ARGB
*/
Bool cursor_argb;
/**
* Track whether cursor is within CRTC range
*/
Bool cursor_in_range;
/**
* Track state of cursor associated with this CRTC
*/
Bool cursor_shown;
};
typedef struct _xf86OutputFuncs {
@ -482,7 +529,8 @@ typedef struct _xf86CrtcConfig {
int maxWidth, maxHeight;
/* For crtc-based rotation */
DamagePtr rotationDamage;
DamagePtr rotation_damage;
Bool rotation_damage_registered;
/* DGA */
unsigned int dga_flags;
@ -495,6 +543,15 @@ typedef struct _xf86CrtcConfig {
const xf86CrtcConfigFuncsRec *funcs;
CreateScreenResourcesProcPtr CreateScreenResources;
CloseScreenProcPtr CloseScreen;
/* Cursor information */
xf86CursorInfoPtr cursor_info;
CursorPtr cursor;
CARD8 *cursor_image;
Bool cursor_on;
CARD32 cursor_fg, cursor_bg;
} xf86CrtcConfigRec, *xf86CrtcConfigPtr;
extern int xf86CrtcConfigPrivateIndex;
@ -538,6 +595,12 @@ xf86CrtcSetMode (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation,
Bool
xf86CrtcRotate (xf86CrtcPtr crtc, DisplayModePtr mode, Rotation rotation);
/*
* Clean up rotation during CloseScreen
*/
void
xf86RotateCloseScreen (ScreenPtr pScreen);
/**
* Return whether any output is assigned to the crtc
*/
@ -637,4 +700,41 @@ xf86ConnectorGetName(xf86ConnectorType connector);
Bool
xf86SetDesiredModes (ScrnInfoPtr pScrn);
/**
* Initialize the CRTC-based cursor code. CRTC function vectors must
* contain relevant cursor setting functions.
*
* Driver should call this from ScreenInit function
*/
Bool
xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags);
/**
* Called when anything on the screen is reconfigured.
*
* Reloads cursor images as needed, then adjusts cursor positions.
*
* Driver should call this from crtc commit function.
*/
void
xf86_reload_cursors (ScreenPtr screen);
/**
* Called from EnterVT to turn the cursors back on
*/
void
xf86_show_cursors (ScrnInfoPtr scrn);
/**
* Called by the driver to turn cursors off
*/
void
xf86_hide_cursors (ScrnInfoPtr scrn);
/**
* Clean up CRTC-based cursor code. Driver must call this at CloseScreen time.
*/
void
xf86_cursors_fini (ScreenPtr screen);
#endif /* _XF86CRTC_H_ */

607
hw/xfree86/modes/xf86Cursors.c Normal file
View File

@ -0,0 +1,607 @@
/*
* Copyright © 2007 Keith Packard
*
* 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 not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. The copyright holders 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 DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THE 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_XORG_CONFIG_H
#include <xorg-config.h>
#else
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#endif
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include "xf86.h"
#include "xf86DDC.h"
#include "xf86Crtc.h"
#include "xf86Modes.h"
#include "xf86RandR12.h"
#include "X11/extensions/render.h"
#define DPMS_SERVER
#include "X11/extensions/dpms.h"
#include "X11/Xatom.h"
#ifdef RENDER
#include "picturestr.h"
#endif
#include "cursorstr.h"
/*
* Given a screen coordinate, rotate back to a cursor source coordinate
*/
static void
xf86_crtc_rotate_coord (Rotation rotation,
int width,
int height,
int x_dst,
int y_dst,
int *x_src,
int *y_src)
{
if (rotation & RR_Reflect_X)
x_dst = width - x_dst - 1;
if (rotation & RR_Reflect_Y)
y_dst = height - y_dst - 1;
switch (rotation & 0xf) {
case RR_Rotate_0:
*x_src = x_dst;
*y_src = y_dst;
break;
case RR_Rotate_90:
*x_src = height - y_dst - 1;
*y_src = x_dst;
break;
case RR_Rotate_180:
*x_src = width - x_dst - 1;
*y_src = height - y_dst - 1;
break;
case RR_Rotate_270:
*x_src = y_dst;
*y_src = width - x_dst - 1;
break;
}
}
/*
* Convert an x coordinate to a position within the cursor bitmap
*/
static int
cursor_bitpos (int flags, int x, Bool mask)
{
if (flags & HARDWARE_CURSOR_SWAP_SOURCE_AND_MASK)
mask = !mask;
if (flags & HARDWARE_CURSOR_NIBBLE_SWAPPED)
x = (x & ~3) | (3 - (x & 3));
if (flags & HARDWARE_CURSOR_BIT_ORDER_MSBFIRST)
x = (x & ~7) | (7 - (x & 7));
if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_1)
x = (x << 1) + mask;
else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_8)
x = ((x & ~7) << 1) | (mask << 3) | (x & 7);
else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_16)
x = ((x & ~15) << 1) | (mask << 4) | (x & 15);
else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_32)
x = ((x & ~31) << 1) | (mask << 5) | (x & 31);
else if (flags & HARDWARE_CURSOR_SOURCE_MASK_INTERLEAVE_64)
x = ((x & ~63) << 1) | (mask << 6) | (x & 63);
return x;
}
/*
* Fetch one bit from a cursor bitmap
*/
static CARD8
get_bit (CARD8 *image, int stride, int flags, int x, int y, Bool mask)
{
x = cursor_bitpos (flags, x, mask);
image += y * stride;
return (image[(x >> 3)] >> (x & 7)) & 1;
}
/*
* Set one bit in a cursor bitmap
*/
static void
set_bit (CARD8 *image, int stride, int flags, int x, int y, Bool mask)
{
x = cursor_bitpos (flags, x, mask);
image += y * stride;
image[(x >> 3)] |= 1 << (x & 7);
}
/*
* Load a two color cursor into a driver that supports only ARGB cursors
*/
static void
xf86_crtc_convert_cursor_to_argb (xf86CrtcPtr crtc, unsigned char *src)
{
ScrnInfoPtr scrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
CARD32 *cursor_image = (CARD32 *) xf86_config->cursor_image;
int x, y;
int xin, yin;
int stride = cursor_info->MaxWidth >> 2;
int flags = cursor_info->Flags;
CARD32 bits;
#ifdef ARGB_CURSOR
crtc->cursor_argb = FALSE;
#endif
for (y = 0; y < cursor_info->MaxHeight; y++)
for (x = 0; x < cursor_info->MaxWidth; x++)
{
xf86_crtc_rotate_coord (crtc->rotation,
cursor_info->MaxWidth,
cursor_info->MaxHeight,
x, y, &xin, &yin);
if (get_bit (src, stride, flags, xin, yin, TRUE) ==
((flags & HARDWARE_CURSOR_INVERT_MASK) == 0))
{
if (get_bit (src, stride, flags, xin, yin, FALSE))
bits = xf86_config->cursor_fg;
else
bits = xf86_config->cursor_bg;
}
else
bits = 0;
cursor_image[y * cursor_info->MaxWidth + x] = bits;
}
crtc->funcs->load_cursor_argb (crtc, cursor_image);
}
/*
* Set the colors for a two-color cursor (ignore for ARGB cursors)
*/
static void
xf86_set_cursor_colors (ScrnInfoPtr scrn, int bg, int fg)
{
ScreenPtr screen = scrn->pScreen;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
CursorPtr cursor = xf86_config->cursor;
int c;
CARD8 *bits = cursor ? cursor->devPriv[screen->myNum] : NULL;
/* Save ARGB versions of these colors */
xf86_config->cursor_fg = (CARD32) fg | 0xff000000;
xf86_config->cursor_bg = (CARD32) bg | 0xff000000;
for (c = 0; c < xf86_config->num_crtc; c++)
{
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->enabled && !crtc->cursor_argb)
{
if (crtc->funcs->load_cursor_image)
crtc->funcs->set_cursor_colors (crtc, bg, fg);
else if (bits)
xf86_crtc_convert_cursor_to_argb (crtc, bits);
}
}
}
static void
xf86_crtc_hide_cursor (xf86CrtcPtr crtc)
{
if (crtc->cursor_shown)
{
crtc->funcs->hide_cursor (crtc);
crtc->cursor_shown = FALSE;
}
}
void
xf86_hide_cursors (ScrnInfoPtr scrn)
{
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
int c;
xf86_config->cursor_on = FALSE;
for (c = 0; c < xf86_config->num_crtc; c++)
{
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->enabled)
xf86_crtc_hide_cursor (crtc);
}
}
static void
xf86_crtc_show_cursor (xf86CrtcPtr crtc)
{
if (!crtc->cursor_shown && crtc->cursor_in_range)
{
crtc->funcs->show_cursor (crtc);
crtc->cursor_shown = TRUE;
}
}
void
xf86_show_cursors (ScrnInfoPtr scrn)
{
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
int c;
xf86_config->cursor_on = TRUE;
for (c = 0; c < xf86_config->num_crtc; c++)
{
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->enabled)
xf86_crtc_show_cursor (crtc);
}
}
static void
xf86_crtc_set_cursor_position (xf86CrtcPtr crtc, int x, int y)
{
ScrnInfoPtr scrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
DisplayModePtr mode = &crtc->mode;
int x_temp;
int y_temp;
Bool in_range;
/*
* Move to crtc coordinate space
*/
x -= crtc->x;
y -= crtc->y;
/*
* Rotate
*/
switch ((crtc->rotation) & 0xf) {
case RR_Rotate_0:
break;
case RR_Rotate_90:
x_temp = y;
y_temp = mode->VDisplay - cursor_info->MaxWidth - x;
x = x_temp;
y = y_temp;
break;
case RR_Rotate_180:
x_temp = mode->HDisplay - cursor_info->MaxWidth - x;
y_temp = mode->VDisplay - cursor_info->MaxHeight - y;
x = x_temp;
y = y_temp;
break;
case RR_Rotate_270:
x_temp = mode->HDisplay - cursor_info->MaxHeight - y;
y_temp = x;
x = x_temp;
y = y_temp;
break;
}
/*
* Reflect
*/
if (crtc->rotation & RR_Reflect_X)
x = mode->HDisplay - cursor_info->MaxWidth - x;
if (crtc->rotation & RR_Reflect_Y)
y = mode->VDisplay - cursor_info->MaxHeight - y;
/*
* Disable the cursor when it is outside the viewport
*/
in_range = TRUE;
if (x >= mode->HDisplay || y >= mode->VDisplay ||
x <= -cursor_info->MaxWidth || y <= -cursor_info->MaxHeight)
{
in_range = FALSE;
x = 0;
y = 0;
}
crtc->cursor_in_range = in_range;
if (in_range)
{
crtc->funcs->set_cursor_position (crtc, x, y);
xf86_crtc_show_cursor (crtc);
}
else
xf86_crtc_hide_cursor (crtc);
}
static void
xf86_set_cursor_position (ScrnInfoPtr scrn, int x, int y)
{
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
int c;
/* undo what xf86HWCurs did to the coordinates */
x += scrn->frameX0;
y += scrn->frameY0;
for (c = 0; c < xf86_config->num_crtc; c++)
{
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->enabled)
xf86_crtc_set_cursor_position (crtc, x, y);
}
}
/*
* Load a two-color cursor into a crtc, performing rotation as needed
*/
static void
xf86_crtc_load_cursor_image (xf86CrtcPtr crtc, CARD8 *src)
{
ScrnInfoPtr scrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
CARD8 *cursor_image;
#ifdef ARGB_CURSOR
crtc->cursor_argb = FALSE;
#endif
if (crtc->rotation == RR_Rotate_0)
cursor_image = src;
else
{
int x, y;
int xin, yin;
int stride = cursor_info->MaxWidth >> 2;
int flags = cursor_info->Flags;
cursor_image = xf86_config->cursor_image;
memset(cursor_image, 0, cursor_info->MaxWidth * stride);
for (y = 0; y < cursor_info->MaxHeight; y++)
for (x = 0; x < cursor_info->MaxWidth; x++)
{
xf86_crtc_rotate_coord (crtc->rotation,
cursor_info->MaxWidth,
cursor_info->MaxHeight,
x, y, &xin, &yin);
if (get_bit(src, stride, flags, xin, yin, FALSE))
set_bit(cursor_image, stride, flags, x, y, FALSE);
if (get_bit(src, stride, flags, xin, yin, TRUE))
set_bit(cursor_image, stride, flags, x, y, TRUE);
}
}
crtc->funcs->load_cursor_image (crtc, cursor_image);
}
/*
* Load a cursor image into all active CRTCs
*/
static void
xf86_load_cursor_image (ScrnInfoPtr scrn, unsigned char *src)
{
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
int c;
for (c = 0; c < xf86_config->num_crtc; c++)
{
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->enabled)
{
if (crtc->funcs->load_cursor_image)
xf86_crtc_load_cursor_image (crtc, src);
else if (crtc->funcs->load_cursor_argb)
xf86_crtc_convert_cursor_to_argb (crtc, src);
}
}
}
static Bool
xf86_use_hw_cursor (ScreenPtr screen, CursorPtr cursor)
{
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
xf86_config->cursor = cursor;
if (cursor->bits->width > cursor_info->MaxWidth ||
cursor->bits->height> cursor_info->MaxHeight)
return FALSE;
return TRUE;
}
static Bool
xf86_use_hw_cursor_argb (ScreenPtr screen, CursorPtr cursor)
{
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
xf86_config->cursor = cursor;
/* Make sure ARGB support is available */
if ((cursor_info->Flags & HARDWARE_CURSOR_ARGB) == 0)
return FALSE;
if (cursor->bits->width > cursor_info->MaxWidth ||
cursor->bits->height> cursor_info->MaxHeight)
return FALSE;
return TRUE;
}
static void
xf86_crtc_load_cursor_argb (xf86CrtcPtr crtc, CursorPtr cursor)
{
ScrnInfoPtr scrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
CARD32 *cursor_image = (CARD32 *) xf86_config->cursor_image;
CARD32 *cursor_source = (CARD32 *) cursor->bits->argb;
int x, y;
int xin, yin;
CARD32 bits;
int source_width = cursor->bits->width;
int source_height = cursor->bits->height;
int image_width = cursor_info->MaxWidth;
int image_height = cursor_info->MaxHeight;
for (y = 0; y < image_height; y++)
for (x = 0; x < image_width; x++)
{
xf86_crtc_rotate_coord (crtc->rotation, image_width, image_height,
x, y, &xin, &yin);
if (xin < source_width && yin < source_height)
bits = cursor_source[yin * source_width + xin];
else
bits = 0;
cursor_image[y * image_width + x] = bits;
}
crtc->funcs->load_cursor_argb (crtc, cursor_image);
}
static void
xf86_load_cursor_argb (ScrnInfoPtr scrn, CursorPtr cursor)
{
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
int c;
for (c = 0; c < xf86_config->num_crtc; c++)
{
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->enabled)
xf86_crtc_load_cursor_argb (crtc, cursor);
}
}
Bool
xf86_cursors_init (ScreenPtr screen, int max_width, int max_height, int flags)
{
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info;
cursor_info = xf86CreateCursorInfoRec();
if (!cursor_info)
return FALSE;
xf86_config->cursor_image = xalloc (max_width * max_height * 4);
if (!xf86_config->cursor_image)
{
xf86DestroyCursorInfoRec (cursor_info);
return FALSE;
}
xf86_config->cursor_info = cursor_info;
cursor_info->MaxWidth = max_width;
cursor_info->MaxHeight = max_height;
cursor_info->Flags = flags;
cursor_info->SetCursorColors = xf86_set_cursor_colors;
cursor_info->SetCursorPosition = xf86_set_cursor_position;
cursor_info->LoadCursorImage = xf86_load_cursor_image;
cursor_info->HideCursor = xf86_hide_cursors;
cursor_info->ShowCursor = xf86_show_cursors;
cursor_info->UseHWCursor = xf86_use_hw_cursor;
#ifdef ARGB_CURSOR
if (flags & HARDWARE_CURSOR_ARGB)
{
cursor_info->UseHWCursorARGB = xf86_use_hw_cursor_argb;
cursor_info->LoadCursorARGB = xf86_load_cursor_argb;
}
#endif
xf86_config->cursor = NULL;
xf86_hide_cursors (scrn);
return xf86InitCursor (screen, cursor_info);
}
/**
* Called when anything on the screen is reconfigured.
*
* Reloads cursor images as needed, then adjusts cursor positions
*/
void
xf86_reload_cursors (ScreenPtr screen)
{
ScrnInfoPtr scrn;
xf86CrtcConfigPtr xf86_config;
xf86CursorInfoPtr cursor_info;
CursorPtr cursor;
int x, y;
/* initial mode setting will not have set a screen yet */
if (!screen)
return;
scrn = xf86Screens[screen->myNum];
xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
/* make sure the cursor code has been initialized */
cursor_info = xf86_config->cursor_info;
if (!cursor_info)
return;
cursor = xf86_config->cursor;
GetSpritePosition (&x, &y);
if (!(cursor_info->Flags & HARDWARE_CURSOR_UPDATE_UNHIDDEN))
(*cursor_info->HideCursor)(scrn);
if (cursor)
{
#ifdef ARGB_CURSOR
if (cursor->bits->argb && cursor_info->LoadCursorARGB)
(*cursor_info->LoadCursorARGB) (scrn, cursor);
else
#endif
(*cursor_info->LoadCursorImage)(cursor_info->pScrn,
cursor->devPriv[screen->myNum]);
(*cursor_info->SetCursorPosition)(cursor_info->pScrn, x, y);
(*cursor_info->ShowCursor)(cursor_info->pScrn);
}
}
/**
* Clean up CRTC-based cursor code
*/
void
xf86_cursors_fini (ScreenPtr screen)
{
ScrnInfoPtr scrn = xf86Screens[screen->myNum];
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
if (xf86_config->cursor_info)
{
xf86DestroyCursorInfoRec (xf86_config->cursor_info);
xf86_config->cursor_info = NULL;
}
if (xf86_config->cursor_image)
{
xfree (xf86_config->cursor_image);
xf86_config->cursor_image = NULL;
}
}

140
hw/xfree86/modes/xf86RandR12.c
View File

@ -556,6 +556,56 @@ xf86RandR12GetOriginalVirtualSize(ScrnInfoPtr pScrn, int *x, int *y)
}
#if RANDR_12_INTERFACE
#define FLAG_BITS (RR_HSyncPositive | \
RR_HSyncNegative | \
RR_VSyncPositive | \
RR_VSyncNegative | \
RR_Interlace | \
RR_DoubleScan | \
RR_CSync | \
RR_CSyncPositive | \
RR_CSyncNegative | \
RR_HSkewPresent | \
RR_BCast | \
RR_PixelMultiplex | \
RR_DoubleClock | \
RR_ClockDivideBy2)
static Bool
xf86RandRModeMatches (RRModePtr randr_mode,
DisplayModePtr mode)
{
#if 0
if (match_name)
{
/* check for same name */
int len = strlen (mode->name);
if (randr_mode->mode.nameLength != len) return FALSE;
if (memcmp (randr_mode->name, mode->name, len) != 0) return FALSE;
}
#endif
/* check for same timings */
if (randr_mode->mode.dotClock / 1000 != mode->Clock) return FALSE;
if (randr_mode->mode.width != mode->HDisplay) return FALSE;
if (randr_mode->mode.hSyncStart != mode->HSyncStart) return FALSE;
if (randr_mode->mode.hSyncEnd != mode->HSyncEnd) return FALSE;
if (randr_mode->mode.hTotal != mode->HTotal) return FALSE;
if (randr_mode->mode.hSkew != mode->HSkew) return FALSE;
if (randr_mode->mode.height != mode->VDisplay) return FALSE;
if (randr_mode->mode.vSyncStart != mode->VSyncStart) return FALSE;
if (randr_mode->mode.vSyncEnd != mode->VSyncEnd) return FALSE;
if (randr_mode->mode.vTotal != mode->VTotal) return FALSE;
/* check for same flags (using only the XF86 valid flag bits) */
if ((randr_mode->mode.modeFlags & FLAG_BITS) != (mode->Flags & FLAG_BITS))
return FALSE;
/* everything matches */
return TRUE;
}
static Bool
xf86RandR12CrtcNotify (RRCrtcPtr randr_crtc)
{
@ -594,12 +644,15 @@ xf86RandR12CrtcNotify (RRCrtcPtr randr_crtc)
* We make copies of modes, so pointer equality
* isn't sufficient
*/
for (j = 0; j < randr_output->numModes; j++)
for (j = 0; j < randr_output->numModes + randr_output->numUserModes; j++)
{
DisplayModePtr outMode = randr_output->modes[j]->devPrivate;
if (xf86ModesEqual(mode, outMode))
RRModePtr m = (j < randr_output->numModes ?
randr_output->modes[j] :
randr_output->userModes[j-randr_output->numModes]);
if (xf86RandRModeMatches (m, mode))
{
randr_mode = randr_output->modes[j];
randr_mode = m;
break;
}
}
@ -611,6 +664,39 @@ xf86RandR12CrtcNotify (RRCrtcPtr randr_crtc)
return ret;
}
/*
* Convert a RandR mode to a DisplayMode
*/
static void
xf86RandRModeConvert (ScrnInfoPtr scrn,
RRModePtr randr_mode,
DisplayModePtr mode)
{
mode->prev = NULL;
mode->next = NULL;
mode->name = NULL;
mode->status = MODE_OK;
mode->type = 0;
mode->Clock = randr_mode->mode.dotClock / 1000;
mode->HDisplay = randr_mode->mode.width;
mode->HSyncStart = randr_mode->mode.hSyncStart;
mode->HSyncEnd = randr_mode->mode.hSyncEnd;
mode->HTotal = randr_mode->mode.hTotal;
mode->HSkew = randr_mode->mode.hSkew;
mode->VDisplay = randr_mode->mode.height;
mode->VSyncStart = randr_mode->mode.vSyncStart;
mode->VSyncEnd = randr_mode->mode.vSyncEnd;
mode->VTotal = randr_mode->mode.vTotal;
mode->VScan = 0;
mode->Flags = randr_mode->mode.modeFlags & FLAG_BITS;
xf86SetModeCrtc (mode, scrn->adjustFlags);
}
static Bool
xf86RandR12CrtcSet (ScreenPtr pScreen,
RRCrtcPtr randr_crtc,
@ -624,16 +710,15 @@ xf86RandR12CrtcSet (ScreenPtr pScreen,
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
xf86CrtcConfigPtr config = XF86_CRTC_CONFIG_PTR(pScrn);
xf86CrtcPtr crtc = randr_crtc->devPrivate;
DisplayModePtr mode = randr_mode ? randr_mode->devPrivate : NULL;
Bool changed = FALSE;
int o, ro;
xf86CrtcPtr *save_crtcs;
Bool save_enabled = crtc->enabled;
save_crtcs = ALLOCATE_LOCAL(config->num_crtc * sizeof (xf86CrtcPtr));
if ((mode != NULL) != crtc->enabled)
if ((randr_mode != NULL) != crtc->enabled)
changed = TRUE;
else if (mode && !xf86ModesEqual (&crtc->mode, mode))
else if (randr_mode && !xf86RandRModeMatches (randr_mode, &crtc->mode))
changed = TRUE;
if (rotation != crtc->rotation)
@ -667,11 +752,14 @@ xf86RandR12CrtcSet (ScreenPtr pScreen,
/* XXX need device-independent mode setting code through an API */
if (changed)
{
crtc->enabled = mode != NULL;
crtc->enabled = randr_mode != NULL;
if (mode)
if (randr_mode)
{
if (!xf86CrtcSetMode (crtc, mode, rotation, x, y))
DisplayModeRec mode;
xf86RandRModeConvert (pScrn, randr_mode, &mode);
if (!xf86CrtcSetMode (crtc, &mode, rotation, x, y))
{
crtc->enabled = save_enabled;
for (o = 0; o < config->num_output; o++)
@ -685,7 +773,7 @@ xf86RandR12CrtcSet (ScreenPtr pScreen,
/*
* Save the last successful setting for EnterVT
*/
crtc->desiredMode = *mode;
crtc->desiredMode = mode;
crtc->desiredRotation = rotation;
crtc->desiredX = x;
crtc->desiredY = y;
@ -728,6 +816,26 @@ xf86RandR12OutputSetProperty (ScreenPtr pScreen,
return output->funcs->set_property(output, property, value);
}
static Bool
xf86RandR12OutputValidateMode (ScreenPtr pScreen,
RROutputPtr randr_output,
RRModePtr randr_mode)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
xf86OutputPtr output = randr_output->devPrivate;
DisplayModeRec mode;
xf86RandRModeConvert (pScrn, randr_mode, &mode);
if (output->funcs->mode_valid (output, &mode) != MODE_OK)
return FALSE;
return TRUE;
}
static void
xf86RandR12ModeDestroy (ScreenPtr pScreen, RRModePtr randr_mode)
{
}
/**
* Given a list of xf86 modes and a RandR Output object, construct
* RandR modes and assign them to the output
@ -774,7 +882,6 @@ xf86RROutputSetModes (RROutputPtr randr_output, DisplayModePtr modes)
rrmode = RRModeGet (&modeInfo, mode->name);
if (rrmode) {
rrmode->devPrivate = mode;
rrmodes[nmode++] = rrmode;
npreferred += pref;
}
@ -904,8 +1011,7 @@ xf86RandR12CreateObjects12 (ScreenPtr pScreen)
{
xf86CrtcPtr crtc = config->crtc[c];
crtc->randr_crtc = RRCrtcCreate (crtc);
RRCrtcAttachScreen (crtc->randr_crtc, pScreen);
crtc->randr_crtc = RRCrtcCreate (pScreen, crtc);
RRCrtcGammaSetSize (crtc->randr_crtc, 256);
}
/*
@ -915,13 +1021,13 @@ xf86RandR12CreateObjects12 (ScreenPtr pScreen)
{
xf86OutputPtr output = config->output[o];
output->randr_output = RROutputCreate (output->name,
output->randr_output = RROutputCreate (pScreen, output->name,
strlen (output->name),
output);
RROutputAttachScreen (output->randr_output, pScreen);
if (output->funcs->create_resources != NULL)
output->funcs->create_resources(output);
RRPostPendingProperties (output->randr_output);
}
return TRUE;
}
@ -958,6 +1064,8 @@ xf86RandR12Init12 (ScreenPtr pScreen)
rp->rrCrtcSet = xf86RandR12CrtcSet;
rp->rrCrtcSetGamma = xf86RandR12CrtcSetGamma;
rp->rrOutputSetProperty = xf86RandR12OutputSetProperty;
rp->rrOutputValidateMode = xf86RandR12OutputValidateMode;
rp->rrModeDestroy = xf86RandR12ModeDestroy;
rp->rrSetConfig = NULL;
pScrn->PointerMoved = xf86RandR12PointerMoved;
if (!xf86RandR12CreateObjects12 (pScreen))

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