From e440ea768d004ca83993dfb5774daa7971d90c10 Mon Sep 17 00:00:00 2001 From: Mike Gabriel Date: Tue, 7 Jun 2016 10:26:58 +0200 Subject: randr extension: Convert to Xorg coding style. The reformatting has been achieved by applying x-indent.sh to all .c and .h files in Xserver/randr/. --- nx-X11/programs/Xserver/randr/panoramiXproto.h | 206 ++-- nx-X11/programs/Xserver/randr/randr.c | 404 ++++---- nx-X11/programs/Xserver/randr/randr.h | 18 +- nx-X11/programs/Xserver/randr/randrproto.h | 759 +++++++------- nx-X11/programs/Xserver/randr/randrstr.h | 585 +++++------ nx-X11/programs/Xserver/randr/registry.h | 8 +- nx-X11/programs/Xserver/randr/rrcrtc.c | 1023 +++++++++---------- nx-X11/programs/Xserver/randr/rrdispatch.c | 267 +++-- nx-X11/programs/Xserver/randr/rrinfo.c | 289 +++--- nx-X11/programs/Xserver/randr/rrmode.c | 429 ++++---- nx-X11/programs/Xserver/randr/rroutput.c | 489 +++++---- nx-X11/programs/Xserver/randr/rrpointer.c | 142 ++- nx-X11/programs/Xserver/randr/rrproperty.c | 833 ++++++++-------- nx-X11/programs/Xserver/randr/rrscreen.c | 1272 +++++++++++------------- nx-X11/programs/Xserver/randr/rrsdispatch.c | 166 ++-- nx-X11/programs/Xserver/randr/rrxinerama.c | 320 +++--- 16 files changed, 3511 insertions(+), 3699 deletions(-) diff --git a/nx-X11/programs/Xserver/randr/panoramiXproto.h b/nx-X11/programs/Xserver/randr/panoramiXproto.h index 2282e03f0..2794b8d03 100644 --- a/nx-X11/programs/Xserver/randr/panoramiXproto.h +++ b/nx-X11/programs/Xserver/randr/panoramiXproto.h @@ -41,152 +41,160 @@ Equipment Corporation. #define X_XineramaQueryScreens 5 typedef struct _PanoramiXQueryVersion { - CARD8 reqType; /* always PanoramiXReqCode */ - CARD8 panoramiXReqType; /* always X_PanoramiXQueryVersion */ - CARD16 length B16; - CARD8 clientMajor; - CARD8 clientMinor; - CARD16 unused B16; + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXQueryVersion */ + CARD16 length B16; + CARD8 clientMajor; + CARD8 clientMinor; + CARD16 unused B16; } xPanoramiXQueryVersionReq; #define sz_xPanoramiXQueryVersionReq 8 typedef struct { - CARD8 type; /* must be X_Reply */ - CARD8 pad1; /* unused */ - CARD16 sequenceNumber B16; /* last sequence number */ - CARD32 length B32; /* 0 */ - CARD16 majorVersion B16; - CARD16 minorVersion B16; - CARD32 pad2 B32; /* unused */ - CARD32 pad3 B32; /* unused */ - CARD32 pad4 B32; /* unused */ - CARD32 pad5 B32; /* unused */ - CARD32 pad6 B32; /* unused */ + CARD8 type; /* must be X_Reply */ + CARD8 pad1; /* unused */ + CARD16 sequenceNumber B16; /* last sequence number */ + CARD32 length B32; /* 0 */ + CARD16 majorVersion B16; + CARD16 minorVersion B16; + CARD32 pad2 B32; /* unused */ + CARD32 pad3 B32; /* unused */ + CARD32 pad4 B32; /* unused */ + CARD32 pad5 B32; /* unused */ + CARD32 pad6 B32; /* unused */ } xPanoramiXQueryVersionReply; #define sz_xPanoramiXQueryVersionReply 32 - -typedef struct _PanoramiXGetState { - CARD8 reqType; /* always PanoramiXReqCode */ - CARD8 panoramiXReqType; /* always X_PanoramiXGetState */ - CARD16 length B16; - CARD32 window B32; +typedef struct _PanoramiXGetState { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXGetState */ + CARD16 length B16; + CARD32 window B32; } xPanoramiXGetStateReq; -#define sz_xPanoramiXGetStateReq 8 + +#define sz_xPanoramiXGetStateReq 8 typedef struct { - BYTE type; - BYTE state; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD32 window B32; - CARD32 pad1 B32; /* unused */ - CARD32 pad2 B32; /* unused */ - CARD32 pad3 B32; /* unused */ - CARD32 pad4 B32; /* unused */ - CARD32 pad5 B32; /* unused */ + BYTE type; + BYTE state; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 window B32; + CARD32 pad1 B32; /* unused */ + CARD32 pad2 B32; /* unused */ + CARD32 pad3 B32; /* unused */ + CARD32 pad4 B32; /* unused */ + CARD32 pad5 B32; /* unused */ } xPanoramiXGetStateReply; #define sz_panoramiXGetStateReply 32 -typedef struct _PanoramiXGetScreenCount { - CARD8 reqType; /* always PanoramiXReqCode */ - CARD8 panoramiXReqType; /* always X_PanoramiXGetScreenCount */ - CARD16 length B16; - CARD32 window B32; +typedef struct _PanoramiXGetScreenCount { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXGetScreenCount */ + CARD16 length B16; + CARD32 window B32; } xPanoramiXGetScreenCountReq; + #define sz_xPanoramiXGetScreenCountReq 8 typedef struct { - BYTE type; - BYTE ScreenCount; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD32 window B32; - CARD32 pad1 B32; /* unused */ - CARD32 pad2 B32; /* unused */ - CARD32 pad3 B32; /* unused */ - CARD32 pad4 B32; /* unused */ - CARD32 pad5 B32; /* unused */ + BYTE type; + BYTE ScreenCount; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 window B32; + CARD32 pad1 B32; /* unused */ + CARD32 pad2 B32; /* unused */ + CARD32 pad3 B32; /* unused */ + CARD32 pad4 B32; /* unused */ + CARD32 pad5 B32; /* unused */ } xPanoramiXGetScreenCountReply; + #define sz_panoramiXGetScreenCountReply 32 -typedef struct _PanoramiXGetScreenSize { - CARD8 reqType; /* always PanoramiXReqCode */ - CARD8 panoramiXReqType; /* always X_PanoramiXGetState */ - CARD16 length B16; - CARD32 window B32; - CARD32 screen B32; +typedef struct _PanoramiXGetScreenSize { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXGetState */ + CARD16 length B16; + CARD32 window B32; + CARD32 screen B32; } xPanoramiXGetScreenSizeReq; -#define sz_xPanoramiXGetScreenSizeReq 12 + +#define sz_xPanoramiXGetScreenSizeReq 12 typedef struct { - BYTE type; - CARD8 pad1; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD32 width B32; - CARD32 height B32; - CARD32 window B32; - CARD32 screen B32; - CARD32 pad2 B32; /* unused */ - CARD32 pad3 B32; /* unused */ + BYTE type; + CARD8 pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 width B32; + CARD32 height B32; + CARD32 window B32; + CARD32 screen B32; + CARD32 pad2 B32; /* unused */ + CARD32 pad3 B32; /* unused */ } xPanoramiXGetScreenSizeReply; -#define sz_panoramiXGetScreenSizeReply 32 + +#define sz_panoramiXGetScreenSizeReply 32 /************ Alternate protocol ******************/ typedef struct { - CARD8 reqType; - CARD8 panoramiXReqType; - CARD16 length B16; + CARD8 reqType; + CARD8 panoramiXReqType; + CARD16 length B16; } xXineramaIsActiveReq; + #define sz_xXineramaIsActiveReq 4 typedef struct { - BYTE type; - CARD8 pad1; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD32 state B32; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; + CARD8 pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 state B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; } xXineramaIsActiveReply; -#define sz_XineramaIsActiveReply 32 +#define sz_XineramaIsActiveReply 32 typedef struct { - CARD8 reqType; - CARD8 panoramiXReqType; - CARD16 length B16; + CARD8 reqType; + CARD8 panoramiXReqType; + CARD16 length B16; } xXineramaQueryScreensReq; + #define sz_xXineramaQueryScreensReq 4 typedef struct { - BYTE type; - CARD8 pad1; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD32 number B32; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; + CARD8 pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 number B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; } xXineramaQueryScreensReply; -#define sz_XineramaQueryScreensReply 32 + +#define sz_XineramaQueryScreensReply 32 typedef struct { - INT16 x_org B16; - INT16 y_org B16; - CARD16 width B16; - CARD16 height B16; + INT16 x_org B16; + INT16 y_org B16; + CARD16 width B16; + CARD16 height B16; } xXineramaScreenInfo; + #define sz_XineramaScreenInfo 8 #endif diff --git a/nx-X11/programs/Xserver/randr/randr.c b/nx-X11/programs/Xserver/randr/randr.c index 11975cb3c..1cb7e5b77 100644 --- a/nx-X11/programs/Xserver/randr/randr.c +++ b/nx-X11/programs/Xserver/randr/randr.c @@ -56,7 +56,7 @@ #endif #define RR_VALIDATE -static int RRNScreens; +static int RRNScreens; #define wrap(priv,real,mem,func) {\ priv->mem = real->mem; \ @@ -67,74 +67,72 @@ static int RRNScreens; real->mem = priv->mem; \ } -static int ProcRRDispatch (ClientPtr pClient); -static int SProcRRDispatch (ClientPtr pClient); +static int ProcRRDispatch(ClientPtr pClient); +static int SProcRRDispatch(ClientPtr pClient); -int RREventBase; -int RRErrorBase; -RESTYPE RRClientType, RREventType; /* resource types for event masks */ +int RREventBase; +int RRErrorBase; +RESTYPE RRClientType, RREventType; /* resource types for event masks */ #ifndef NXAGENT_SERVER DevPrivateKey RRClientPrivateKey = &RRClientPrivateKey; DevPrivateKey rrPrivKey = &rrPrivKey; #else -int RRClientPrivateIndex; -int rrPrivIndex = -1; +int RRClientPrivateIndex; +int rrPrivIndex = -1; #endif static void -RRClientCallback (CallbackListPtr *list, - void * closure, - void * data) +RRClientCallback(CallbackListPtr *list, void *closure, void *data) { - NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; - ClientPtr pClient = clientinfo->client; + NewClientInfoRec *clientinfo = (NewClientInfoRec *) data; + ClientPtr pClient = clientinfo->client; + rrClientPriv(pClient); - RRTimesPtr pTimes = (RRTimesPtr) (pRRClient + 1); - int i; + RRTimesPtr pTimes = (RRTimesPtr) (pRRClient + 1); + int i; pRRClient->major_version = 0; pRRClient->minor_version = 0; - for (i = 0; i < screenInfo.numScreens; i++) - { - ScreenPtr pScreen = screenInfo.screens[i]; - rrScrPriv(pScreen); - - if (pScrPriv) - { - pTimes[i].setTime = pScrPriv->lastSetTime; - pTimes[i].configTime = pScrPriv->lastConfigTime; - } + for (i = 0; i < screenInfo.numScreens; i++) { + ScreenPtr pScreen = screenInfo.screens[i]; + + rrScrPriv(pScreen); + + if (pScrPriv) { + pTimes[i].setTime = pScrPriv->lastSetTime; + pTimes[i].configTime = pScrPriv->lastConfigTime; + } } } static void -RRResetProc (ExtensionEntry *extEntry) +RRResetProc(ExtensionEntry * extEntry) { } static Bool -RRCloseScreen (int i, ScreenPtr pScreen) +RRCloseScreen(int i, ScreenPtr pScreen) { rrScrPriv(pScreen); - int j; + int j; - unwrap (pScrPriv, pScreen, CloseScreen); + unwrap(pScrPriv, pScreen, CloseScreen); for (j = pScrPriv->numCrtcs - 1; j >= 0; j--) - RRCrtcDestroy (pScrPriv->crtcs[j]); + RRCrtcDestroy(pScrPriv->crtcs[j]); for (j = pScrPriv->numOutputs - 1; j >= 0; j--) - RROutputDestroy (pScrPriv->outputs[j]); + RROutputDestroy(pScrPriv->outputs[j]); - xfree (pScrPriv->crtcs); - xfree (pScrPriv->outputs); - xfree (pScrPriv); - RRNScreens -= 1; /* ok, one fewer screen with RandR running */ + xfree(pScrPriv->crtcs); + xfree(pScrPriv->outputs); + xfree(pScrPriv); + RRNScreens -= 1; /* ok, one fewer screen with RandR running */ return (*pScreen->CloseScreen) (i, pScreen); } static void -SRRScreenChangeNotifyEvent(xRRScreenChangeNotifyEvent *from, - xRRScreenChangeNotifyEvent *to) +SRRScreenChangeNotifyEvent(xRRScreenChangeNotifyEvent * from, + xRRScreenChangeNotifyEvent * to) { to->type = from->type; to->rotation = from->rotation; @@ -152,8 +150,8 @@ SRRScreenChangeNotifyEvent(xRRScreenChangeNotifyEvent *from, } static void -SRRCrtcChangeNotifyEvent(xRRCrtcChangeNotifyEvent *from, - xRRCrtcChangeNotifyEvent *to) +SRRCrtcChangeNotifyEvent(xRRCrtcChangeNotifyEvent * from, + xRRCrtcChangeNotifyEvent * to) { to->type = from->type; to->subCode = from->subCode; @@ -171,8 +169,8 @@ SRRCrtcChangeNotifyEvent(xRRCrtcChangeNotifyEvent *from, } static void -SRROutputChangeNotifyEvent(xRROutputChangeNotifyEvent *from, - xRROutputChangeNotifyEvent *to) +SRROutputChangeNotifyEvent(xRROutputChangeNotifyEvent * from, + xRROutputChangeNotifyEvent * to) { to->type = from->type; to->subCode = from->subCode; @@ -187,8 +185,8 @@ SRROutputChangeNotifyEvent(xRROutputChangeNotifyEvent *from, } static void -SRROutputPropertyNotifyEvent(xRROutputPropertyNotifyEvent *from, - xRROutputPropertyNotifyEvent *to) +SRROutputPropertyNotifyEvent(xRROutputPropertyNotifyEvent * from, + xRROutputPropertyNotifyEvent * to) { to->type = from->type; to->subCode = from->subCode; @@ -200,58 +198,58 @@ SRROutputPropertyNotifyEvent(xRROutputPropertyNotifyEvent *from, } static void -SRRNotifyEvent (xEvent *from, - xEvent *to) +SRRNotifyEvent(xEvent *from, xEvent *to) { switch (from->u.u.detail) { case RRNotify_CrtcChange: - SRRCrtcChangeNotifyEvent ((xRRCrtcChangeNotifyEvent *) from, - (xRRCrtcChangeNotifyEvent *) to); - break; + SRRCrtcChangeNotifyEvent((xRRCrtcChangeNotifyEvent *) from, + (xRRCrtcChangeNotifyEvent *) to); + break; case RRNotify_OutputChange: - SRROutputChangeNotifyEvent ((xRROutputChangeNotifyEvent *) from, - (xRROutputChangeNotifyEvent *) to); - break; + SRROutputChangeNotifyEvent((xRROutputChangeNotifyEvent *) from, + (xRROutputChangeNotifyEvent *) to); + break; case RRNotify_OutputProperty: - SRROutputPropertyNotifyEvent ((xRROutputPropertyNotifyEvent *) from, - (xRROutputPropertyNotifyEvent *) to); - break; + SRROutputPropertyNotifyEvent((xRROutputPropertyNotifyEvent *) from, + (xRROutputPropertyNotifyEvent *) to); + break; default: - break; + break; } } static int RRGeneration; -Bool RRInit (void) +Bool +RRInit(void) { - if (RRGeneration != serverGeneration) - { - #ifdef NXAGENT_SERVER - if ((rrPrivIndex = AllocateScreenPrivateIndex()) < 0) - return FALSE; - #endif - if (!RRModeInit ()) - return FALSE; - if (!RRCrtcInit ()) - return FALSE; - if (!RROutputInit ()) - return FALSE; - RRGeneration = serverGeneration; + if (RRGeneration != serverGeneration) { +#ifdef NXAGENT_SERVER + if ((rrPrivIndex = AllocateScreenPrivateIndex()) < 0) + return FALSE; +#endif + if (!RRModeInit()) + return FALSE; + if (!RRCrtcInit()) + return FALSE; + if (!RROutputInit()) + return FALSE; + RRGeneration = serverGeneration; } return TRUE; } -Bool RRScreenInit(ScreenPtr pScreen) +Bool +RRScreenInit(ScreenPtr pScreen) { - rrScrPrivPtr pScrPriv; + rrScrPrivPtr pScrPriv; - if (!RRInit ()) - return FALSE; + if (!RRInit()) + return FALSE; - pScrPriv = (rrScrPrivPtr) xcalloc (1, sizeof (rrScrPrivRec)); + pScrPriv = (rrScrPrivPtr) xcalloc(1, sizeof(rrScrPrivRec)); if (!pScrPriv) - return FALSE; + return FALSE; SetRRScreen(pScreen, pScrPriv); @@ -291,145 +289,141 @@ Bool RRScreenInit(ScreenPtr pScreen) pScrPriv->lastSetTime = currentTime; pScrPriv->lastConfigTime = currentTime; - wrap (pScrPriv, pScreen, CloseScreen, RRCloseScreen); + wrap(pScrPriv, pScreen, CloseScreen, RRCloseScreen); pScrPriv->numOutputs = 0; pScrPriv->outputs = NULL; pScrPriv->numCrtcs = 0; pScrPriv->crtcs = NULL; - RRNScreens += 1; /* keep count of screens that implement randr */ + RRNScreens += 1; /* keep count of screens that implement randr */ return TRUE; } -/*ARGSUSED*/ -static int -RRFreeClient (void * data, XID id) + /*ARGSUSED*/ static int +RRFreeClient(void *data, XID id) { - RREventPtr pRREvent; - WindowPtr pWin; - RREventPtr *pHead, pCur, pPrev; + RREventPtr pRREvent; + WindowPtr pWin; + RREventPtr *pHead, pCur, pPrev; pRREvent = (RREventPtr) data; pWin = pRREvent->window; pHead = (RREventPtr *) LookupIDByType(pWin->drawable.id, RREventType); if (pHead) { - pPrev = 0; - for (pCur = *pHead; pCur && pCur != pRREvent; pCur=pCur->next) - pPrev = pCur; - if (pCur) - { - if (pPrev) - pPrev->next = pRREvent->next; - else - *pHead = pRREvent->next; - } + pPrev = 0; + for (pCur = *pHead; pCur && pCur != pRREvent; pCur = pCur->next) + pPrev = pCur; + if (pCur) { + if (pPrev) + pPrev->next = pRREvent->next; + else + *pHead = pRREvent->next; + } } - xfree ((void *) pRREvent); + xfree((void *) pRREvent); return 1; } -/*ARGSUSED*/ -static int -RRFreeEvents (void * data, XID id) + /*ARGSUSED*/ static int +RRFreeEvents(void *data, XID id) { - RREventPtr *pHead, pCur, pNext; + RREventPtr *pHead, pCur, pNext; pHead = (RREventPtr *) data; for (pCur = *pHead; pCur; pCur = pNext) { - pNext = pCur->next; - FreeResource (pCur->clientResource, RRClientType); - xfree ((void *) pCur); + pNext = pCur->next; + FreeResource(pCur->clientResource, RRClientType); + xfree((void *) pCur); } - xfree ((void *) pHead); + xfree((void *) pHead); return 1; } void -RRExtensionInit (void) +RRExtensionInit(void) { ExtensionEntry *extEntry; - if (RRNScreens == 0) return; + if (RRNScreens == 0) + return; - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER if (!dixRequestPrivate(RRClientPrivateKey, - sizeof (RRClientRec) + - screenInfo.numScreens * sizeof (RRTimesRec))) - return; - #else - RRClientPrivateIndex = AllocateClientPrivateIndex (); - if (!AllocateClientPrivate (RRClientPrivateIndex, - sizeof (RRClientRec) + - screenInfo.numScreens * sizeof (RRTimesRec))) - return; - #endif - if (!AddCallback (&ClientStateCallback, RRClientCallback, 0)) - return; + sizeof(RRClientRec) + + screenInfo.numScreens * sizeof(RRTimesRec))) + return; +#else + RRClientPrivateIndex = AllocateClientPrivateIndex(); + if (!AllocateClientPrivate(RRClientPrivateIndex, + sizeof(RRClientRec) + + screenInfo.numScreens * sizeof(RRTimesRec))) + return; +#endif + if (!AddCallback(&ClientStateCallback, RRClientCallback, 0)) + return; RRClientType = CreateNewResourceType(RRFreeClient); if (!RRClientType) - return; + return; RREventType = CreateNewResourceType(RRFreeEvents); if (!RREventType) - return; - extEntry = AddExtension (RANDR_NAME, RRNumberEvents, RRNumberErrors, - ProcRRDispatch, SProcRRDispatch, - RRResetProc, StandardMinorOpcode); + return; + extEntry = AddExtension(RANDR_NAME, RRNumberEvents, RRNumberErrors, + ProcRRDispatch, SProcRRDispatch, + RRResetProc, StandardMinorOpcode); if (!extEntry) - return; + return; RRErrorBase = extEntry->errorBase; RREventBase = extEntry->eventBase; EventSwapVector[RREventBase + RRScreenChangeNotify] = (EventSwapPtr) - SRRScreenChangeNotifyEvent; + SRRScreenChangeNotifyEvent; EventSwapVector[RREventBase + RRNotify] = (EventSwapPtr) - SRRNotifyEvent; + SRRNotifyEvent; #ifdef PANORAMIX RRXineramaExtensionInit(); #endif } static int -TellChanged (WindowPtr pWin, void * value) +TellChanged(WindowPtr pWin, void *value) { - RREventPtr *pHead, pRREvent; - ClientPtr client; - ScreenPtr pScreen = pWin->drawable.pScreen; + RREventPtr *pHead, pRREvent; + ClientPtr client; + ScreenPtr pScreen = pWin->drawable.pScreen; + rrScrPriv(pScreen); - int i; + int i; - pHead = (RREventPtr *) LookupIDByType (pWin->drawable.id, RREventType); + pHead = (RREventPtr *) LookupIDByType(pWin->drawable.id, RREventType); if (!pHead) - return WT_WALKCHILDREN; - - for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) - { - client = pRREvent->client; - if (client == serverClient || client->clientGone) - continue; - - if (pRREvent->mask & RRScreenChangeNotifyMask) - RRDeliverScreenEvent (client, pWin, pScreen); - - if (pRREvent->mask & RRCrtcChangeNotifyMask) - { - for (i = 0; i < pScrPriv->numCrtcs; i++) - { - RRCrtcPtr crtc = pScrPriv->crtcs[i]; - if (crtc->changed) - RRDeliverCrtcEvent (client, pWin, crtc); - } - } - - if (pRREvent->mask & RROutputChangeNotifyMask) - { - for (i = 0; i < pScrPriv->numOutputs; i++) - { - RROutputPtr output = pScrPriv->outputs[i]; - if (output->changed) - RRDeliverOutputEvent (client, pWin, output); - } - } + return WT_WALKCHILDREN; + + for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) { + client = pRREvent->client; + if (client == serverClient || client->clientGone) + continue; + + if (pRREvent->mask & RRScreenChangeNotifyMask) + RRDeliverScreenEvent(client, pWin, pScreen); + + if (pRREvent->mask & RRCrtcChangeNotifyMask) { + for (i = 0; i < pScrPriv->numCrtcs; i++) { + RRCrtcPtr crtc = pScrPriv->crtcs[i]; + + if (crtc->changed) + RRDeliverCrtcEvent(client, pWin, crtc); + } + } + + if (pRREvent->mask & RROutputChangeNotifyMask) { + for (i = 0; i < pScrPriv->numOutputs; i++) { + RROutputPtr output = pScrPriv->outputs[i]; + + if (output->changed) + RRDeliverOutputEvent(client, pWin, output); + } + } } return WT_WALKCHILDREN; } @@ -438,31 +432,28 @@ TellChanged (WindowPtr pWin, void * value) * Something changed; send events and adjust pointer position */ void -RRTellChanged (ScreenPtr pScreen) +RRTellChanged(ScreenPtr pScreen) { - rrScrPriv (pScreen); + rrScrPriv(pScreen); int i; - if (pScrPriv->changed) - { - UpdateCurrentTime (); - if (pScrPriv->configChanged) - { - pScrPriv->lastConfigTime = currentTime; - pScrPriv->configChanged = FALSE; - } - pScrPriv->changed = FALSE; - WalkTree (pScreen, TellChanged, (void *) pScreen); - for (i = 0; i < pScrPriv->numOutputs; i++) - pScrPriv->outputs[i]->changed = FALSE; - for (i = 0; i < pScrPriv->numCrtcs; i++) - pScrPriv->crtcs[i]->changed = FALSE; - if (pScrPriv->layoutChanged) - { - pScrPriv->layoutChanged = FALSE; - RRPointerScreenConfigured (pScreen); - RRSendConfigNotify (pScreen); - } + if (pScrPriv->changed) { + UpdateCurrentTime(); + if (pScrPriv->configChanged) { + pScrPriv->lastConfigTime = currentTime; + pScrPriv->configChanged = FALSE; + } + pScrPriv->changed = FALSE; + WalkTree(pScreen, TellChanged, (void *) pScreen); + for (i = 0; i < pScrPriv->numOutputs; i++) + pScrPriv->outputs[i]->changed = FALSE; + for (i = 0; i < pScrPriv->numCrtcs; i++) + pScrPriv->crtcs[i]->changed = FALSE; + if (pScrPriv->layoutChanged) { + pScrPriv->layoutChanged = FALSE; + RRPointerScreenConfigured(pScreen); + RRSendConfigNotify(pScreen); + } } } @@ -471,53 +462,52 @@ RRTellChanged (ScreenPtr pScreen) * Used in emulating 1.0 behaviour */ RROutputPtr -RRFirstOutput (ScreenPtr pScreen) +RRFirstOutput(ScreenPtr pScreen) { rrScrPriv(pScreen); - RROutputPtr output; - int i, j; - - for (i = 0; i < pScrPriv->numCrtcs; i++) - { - RRCrtcPtr crtc = pScrPriv->crtcs[i]; - for (j = 0; j < pScrPriv->numOutputs; j++) - { - output = pScrPriv->outputs[j]; - if (output->crtc == crtc) - return output; - } + RROutputPtr output; + int i, j; + + for (i = 0; i < pScrPriv->numCrtcs; i++) { + RRCrtcPtr crtc = pScrPriv->crtcs[i]; + + for (j = 0; j < pScrPriv->numOutputs; j++) { + output = pScrPriv->outputs[j]; + if (output->crtc == crtc) + return output; + } } return NULL; } CARD16 -RRVerticalRefresh (xRRModeInfo *mode) +RRVerticalRefresh(xRRModeInfo * mode) { - CARD32 refresh; - CARD32 dots = mode->hTotal * mode->vTotal; + CARD32 refresh; + CARD32 dots = mode->hTotal * mode->vTotal; + if (!dots) - return 0; - refresh = (mode->dotClock + dots/2) / dots; + return 0; + refresh = (mode->dotClock + dots / 2) / dots; if (refresh > 0xffff) - refresh = 0xffff; + refresh = 0xffff; return (CARD16) refresh; } static int -ProcRRDispatch (ClientPtr client) +ProcRRDispatch(ClientPtr client) { REQUEST(xReq); if (stuff->data >= RRNumberRequests || !ProcRandrVector[stuff->data]) - return BadRequest; + return BadRequest; return (*ProcRandrVector[stuff->data]) (client); } static int -SProcRRDispatch (ClientPtr client) +SProcRRDispatch(ClientPtr client) { REQUEST(xReq); if (stuff->data >= RRNumberRequests || !ProcRandrVector[stuff->data]) - return BadRequest; + return BadRequest; return (*SProcRandrVector[stuff->data]) (client); } - diff --git a/nx-X11/programs/Xserver/randr/randr.h b/nx-X11/programs/Xserver/randr/randr.h index 17e6ef9f6..a3ef56c77 100644 --- a/nx-X11/programs/Xserver/randr/randr.h +++ b/nx-X11/programs/Xserver/randr/randr.h @@ -28,14 +28,14 @@ #ifndef _RANDR_H_ #define _RANDR_H_ -typedef unsigned short Rotation; -typedef unsigned short SizeID; -typedef unsigned short SubpixelOrder; -typedef unsigned short Connection; -typedef unsigned short XRandrRotation; -typedef unsigned short XRandrSizeID; -typedef unsigned short XRandrSubpixelOrder; -typedef unsigned long XRandrModeFlags; +typedef unsigned short Rotation; +typedef unsigned short SizeID; +typedef unsigned short SubpixelOrder; +typedef unsigned short Connection; +typedef unsigned short XRandrRotation; +typedef unsigned short XRandrSizeID; +typedef unsigned short XRandrSubpixelOrder; +typedef unsigned long XRandrModeFlags; #define RANDR_NAME "RANDR" #define RANDR_MAJOR 1 @@ -138,4 +138,4 @@ typedef unsigned long XRandrModeFlags; #define RR_PROPERTY_RANDR_EDID "RANDR_EDID" -#endif /* _RANDR_H_ */ +#endif /* _RANDR_H_ */ diff --git a/nx-X11/programs/Xserver/randr/randrproto.h b/nx-X11/programs/Xserver/randr/randrproto.h index 96b954206..be5b7adb5 100644 --- a/nx-X11/programs/Xserver/randr/randrproto.h +++ b/nx-X11/programs/Xserver/randr/randrproto.h @@ -63,6 +63,7 @@ typedef struct { CARD16 widthInMillimeters B16; CARD16 heightInMillimeters B16; } xScreenSizes; + #define sz_xScreenSizes 8 /* @@ -70,34 +71,37 @@ typedef struct { */ typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - CARD32 majorVersion B32; - CARD32 minorVersion B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + CARD32 majorVersion B32; + CARD32 minorVersion B32; } xRRQueryVersionReq; + #define sz_xRRQueryVersionReq 12 typedef struct { - BYTE type; /* X_Reply */ - BYTE pad1; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD32 majorVersion B32; - CARD32 minorVersion B32; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD32 majorVersion B32; + CARD32 minorVersion B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; } xRRQueryVersionReply; + #define sz_xRRQueryVersionReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - Window window B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + Window window B32; } xRRGetScreenInfoReq; + #define sz_xRRGetScreenInfoReq 8 /* @@ -106,73 +110,77 @@ typedef struct { * the size information */ - typedef struct { - BYTE type; /* X_Reply */ - BYTE setOfRotations; - CARD16 sequenceNumber B16; - CARD32 length B32; - Window root B32; - Time timestamp B32; - Time configTimestamp B32; - CARD16 nSizes B16; - SizeID sizeID B16; - Rotation rotation B16; - CARD16 rate B16; - CARD16 nrateEnts B16; - CARD16 pad B16; + BYTE type; /* X_Reply */ + BYTE setOfRotations; + CARD16 sequenceNumber B16; + CARD32 length B32; + Window root B32; + Time timestamp B32; + Time configTimestamp B32; + CARD16 nSizes B16; + SizeID sizeID B16; + Rotation rotation B16; + CARD16 rate B16; + CARD16 nrateEnts B16; + CARD16 pad B16; } xRRGetScreenInfoReply; + #define sz_xRRGetScreenInfoReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; Drawable drawable B32; - Time timestamp B32; - Time configTimestamp B32; - SizeID sizeID B16; + Time timestamp B32; + Time configTimestamp B32; + SizeID sizeID B16; Rotation rotation B16; } xRR1_0SetScreenConfigReq; + #define sz_xRR1_0SetScreenConfigReq 20 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; Drawable drawable B32; - Time timestamp B32; - Time configTimestamp B32; - SizeID sizeID B16; + Time timestamp B32; + Time configTimestamp B32; + SizeID sizeID B16; Rotation rotation B16; - CARD16 rate B16; - CARD16 pad B16; + CARD16 rate B16; + CARD16 pad B16; } xRRSetScreenConfigReq; + #define sz_xRRSetScreenConfigReq 24 typedef struct { - BYTE type; /* X_Reply */ - CARD8 status; - CARD16 sequenceNumber B16; - CARD32 length B32; - Time newTimestamp B32; - Time newConfigTimestamp B32; - Window root; - CARD16 subpixelOrder B16; - CARD16 pad4 B16; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; /* X_Reply */ + CARD8 status; + CARD16 sequenceNumber B16; + CARD32 length B32; + Time newTimestamp B32; + Time newConfigTimestamp B32; + Window root; + CARD16 subpixelOrder B16; + CARD16 pad4 B16; + CARD32 pad5 B32; + CARD32 pad6 B32; } xRRSetScreenConfigReply; + #define sz_xRRSetScreenConfigReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - Window window B32; - CARD16 enable B16; - CARD16 pad2 B16; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + Window window B32; + CARD16 enable B16; + CARD16 pad2 B16; } xRRSelectInputReq; + #define sz_xRRSelectInputReq 12 /* @@ -180,455 +188,490 @@ typedef struct { */ typedef struct _xRRModeInfo { - RRMode id B32; - CARD16 width B16; - CARD16 height B16; - CARD32 dotClock B32; - CARD16 hSyncStart B16; - CARD16 hSyncEnd B16; - CARD16 hTotal B16; - CARD16 hSkew B16; - CARD16 vSyncStart B16; - CARD16 vSyncEnd B16; - CARD16 vTotal B16; - CARD16 nameLength B16; - RRModeFlags modeFlags B32; + RRMode id B32; + CARD16 width B16; + CARD16 height B16; + CARD32 dotClock B32; + CARD16 hSyncStart B16; + CARD16 hSyncEnd B16; + CARD16 hTotal B16; + CARD16 hSkew B16; + CARD16 vSyncStart B16; + CARD16 vSyncEnd B16; + CARD16 vTotal B16; + CARD16 nameLength B16; + RRModeFlags modeFlags B32; } xRRModeInfo; + #define sz_xRRModeInfo 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - Window window B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + Window window B32; } xRRGetScreenSizeRangeReq; + #define sz_xRRGetScreenSizeRangeReq 8 typedef struct { - BYTE type; /* X_Reply */ - CARD8 pad; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD16 minWidth B16; - CARD16 minHeight B16; - CARD16 maxWidth B16; - CARD16 maxHeight B16; - CARD32 pad0 B32; - CARD32 pad1 B32; - CARD32 pad2 B32; - CARD32 pad3 B32; + BYTE type; /* X_Reply */ + CARD8 pad; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 minWidth B16; + CARD16 minHeight B16; + CARD16 maxWidth B16; + CARD16 maxHeight B16; + CARD32 pad0 B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; } xRRGetScreenSizeRangeReply; + #define sz_xRRGetScreenSizeRangeReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - Window window B32; - CARD16 width B16; - CARD16 height B16; - CARD32 widthInMillimeters B32; - CARD32 heightInMillimeters B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + Window window B32; + CARD16 width B16; + CARD16 height B16; + CARD32 widthInMillimeters B32; + CARD32 heightInMillimeters B32; } xRRSetScreenSizeReq; + #define sz_xRRSetScreenSizeReq 20 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - Window window B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + Window window B32; } xRRGetScreenResourcesReq; + #define sz_xRRGetScreenResourcesReq 8 typedef struct { - BYTE type; - CARD8 pad; - CARD16 sequenceNumber B16; - CARD32 length B32; - Time timestamp B32; - Time configTimestamp B32; - CARD16 nCrtcs B16; - CARD16 nOutputs B16; - CARD16 nModes B16; - CARD16 nbytesNames B16; - CARD32 pad1 B32; - CARD32 pad2 B32; + BYTE type; + CARD8 pad; + CARD16 sequenceNumber B16; + CARD32 length B32; + Time timestamp B32; + Time configTimestamp B32; + CARD16 nCrtcs B16; + CARD16 nOutputs B16; + CARD16 nModes B16; + CARD16 nbytesNames B16; + CARD32 pad1 B32; + CARD32 pad2 B32; } xRRGetScreenResourcesReply; + #define sz_xRRGetScreenResourcesReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - Time configTimestamp B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + Time configTimestamp B32; } xRRGetOutputInfoReq; + #define sz_xRRGetOutputInfoReq 12 typedef struct { - BYTE type; - CARD8 status; - CARD16 sequenceNumber B16; - CARD32 length B32; - Time timestamp B32; - RRCrtc crtc B32; - CARD32 mmWidth B32; - CARD32 mmHeight B32; - CARD8 connection; - CARD8 subpixelOrder; - CARD16 nCrtcs B16; - CARD16 nModes B16; - CARD16 nPreferred B16; - CARD16 nClones B16; - CARD16 nameLength B16; + BYTE type; + CARD8 status; + CARD16 sequenceNumber B16; + CARD32 length B32; + Time timestamp B32; + RRCrtc crtc B32; + CARD32 mmWidth B32; + CARD32 mmHeight B32; + CARD8 connection; + CARD8 subpixelOrder; + CARD16 nCrtcs B16; + CARD16 nModes B16; + CARD16 nPreferred B16; + CARD16 nClones B16; + CARD16 nameLength B16; } xRRGetOutputInfoReply; + #define sz_xRRGetOutputInfoReply 36 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; } xRRListOutputPropertiesReq; + #define sz_xRRListOutputPropertiesReq 8 typedef struct { - BYTE type; - CARD8 pad0; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD16 nAtoms B16; - CARD16 pad1 B16; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 nAtoms B16; + CARD16 pad1 B16; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; } xRRListOutputPropertiesReply; + #define sz_xRRListOutputPropertiesReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - Atom property B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + Atom property B32; } xRRQueryOutputPropertyReq; + #define sz_xRRQueryOutputPropertyReq 12 typedef struct { - BYTE type; - BYTE pad0; - CARD16 sequenceNumber B16; - CARD32 length B32; - BOOL pending; - BOOL range; - BOOL immutable; - BYTE pad1; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; + BYTE pad0; + CARD16 sequenceNumber B16; + CARD32 length B32; + BOOL pending; + BOOL range; + BOOL immutable; + BYTE pad1; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; } xRRQueryOutputPropertyReply; + #define sz_xRRQueryOutputPropertyReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - Atom property B32; - BOOL pending; - BOOL range; - CARD16 pad B16; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + Atom property B32; + BOOL pending; + BOOL range; + CARD16 pad B16; } xRRConfigureOutputPropertyReq; + #define sz_xRRConfigureOutputPropertyReq 16 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - Atom property B32; - Atom type B32; - CARD8 format; - CARD8 mode; - CARD16 pad; - CARD32 nUnits B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + Atom property B32; + Atom type B32; + CARD8 format; + CARD8 mode; + CARD16 pad; + CARD32 nUnits B32; } xRRChangeOutputPropertyReq; + #define sz_xRRChangeOutputPropertyReq 24 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - Atom property B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + Atom property B32; } xRRDeleteOutputPropertyReq; + #define sz_xRRDeleteOutputPropertyReq 12 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - Atom property B32; - Atom type B32; - CARD32 longOffset B32; - CARD32 longLength B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + Atom property B32; + Atom type B32; + CARD32 longOffset B32; + CARD32 longLength B32; #ifdef __cplusplus - BOOL _delete; + BOOL _delete; #else - BOOL delete; + BOOL delete; #endif - BOOL pending; - CARD16 pad1 B16; + BOOL pending; + CARD16 pad1 B16; } xRRGetOutputPropertyReq; + #define sz_xRRGetOutputPropertyReq 28 typedef struct { - BYTE type; - CARD8 format; - CARD16 sequenceNumber B16; - CARD32 length B32; - Atom propertyType B32; - CARD32 bytesAfter B32; - CARD32 nItems B32; - CARD32 pad1 B32; - CARD32 pad2 B32; - CARD32 pad3 B32; + BYTE type; + CARD8 format; + CARD16 sequenceNumber B16; + CARD32 length B32; + Atom propertyType B32; + CARD32 bytesAfter B32; + CARD32 nItems B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; } xRRGetOutputPropertyReply; + #define sz_xRRGetOutputPropertyReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - Window window B32; - xRRModeInfo modeInfo; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + Window window B32; + xRRModeInfo modeInfo; } xRRCreateModeReq; + #define sz_xRRCreateModeReq 40 typedef struct { - BYTE type; - CARD8 pad0; - CARD16 sequenceNumber B16; - CARD32 length B32; - RRMode mode B32; - CARD32 pad1 B32; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber B16; + CARD32 length B32; + RRMode mode B32; + CARD32 pad1 B32; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; } xRRCreateModeReply; + #define sz_xRRCreateModeReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RRMode mode B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RRMode mode B32; } xRRDestroyModeReq; + #define sz_xRRDestroyModeReq 8 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - RRMode mode B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + RRMode mode B32; } xRRAddOutputModeReq; + #define sz_xRRAddOutputModeReq 12 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RROutput output B32; - RRMode mode B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RROutput output B32; + RRMode mode B32; } xRRDeleteOutputModeReq; + #define sz_xRRDeleteOutputModeReq 12 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RRCrtc crtc B32; - Time configTimestamp B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RRCrtc crtc B32; + Time configTimestamp B32; } xRRGetCrtcInfoReq; + #define sz_xRRGetCrtcInfoReq 12 typedef struct { - BYTE type; - CARD8 status; - CARD16 sequenceNumber B16; - CARD32 length B32; - Time timestamp B32; - INT16 x B16; - INT16 y B16; - CARD16 width B16; - CARD16 height B16; - RRMode mode B32; - Rotation rotation B16; - Rotation rotations B16; - CARD16 nOutput B16; - CARD16 nPossibleOutput B16; + BYTE type; + CARD8 status; + CARD16 sequenceNumber B16; + CARD32 length B32; + Time timestamp B32; + INT16 x B16; + INT16 y B16; + CARD16 width B16; + CARD16 height B16; + RRMode mode B32; + Rotation rotation B16; + Rotation rotations B16; + CARD16 nOutput B16; + CARD16 nPossibleOutput B16; } xRRGetCrtcInfoReply; + #define sz_xRRGetCrtcInfoReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RRCrtc crtc B32; - Time timestamp B32; - Time configTimestamp B32; - INT16 x B16; - INT16 y B16; - RRMode mode B32; - Rotation rotation B16; - CARD16 pad B16; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RRCrtc crtc B32; + Time timestamp B32; + Time configTimestamp B32; + INT16 x B16; + INT16 y B16; + RRMode mode B32; + Rotation rotation B16; + CARD16 pad B16; } xRRSetCrtcConfigReq; + #define sz_xRRSetCrtcConfigReq 28 typedef struct { - BYTE type; - CARD8 status; - CARD16 sequenceNumber B16; - CARD32 length B32; - Time newTimestamp B32; - CARD32 pad1 B32; - CARD32 pad2 B16; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; + BYTE type; + CARD8 status; + CARD16 sequenceNumber B16; + CARD32 length B32; + Time newTimestamp B32; + CARD32 pad1 B32; + CARD32 pad2 B16; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; } xRRSetCrtcConfigReply; + #define sz_xRRSetCrtcConfigReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RRCrtc crtc B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RRCrtc crtc B32; } xRRGetCrtcGammaSizeReq; + #define sz_xRRGetCrtcGammaSizeReq 8 typedef struct { - BYTE type; - CARD8 status; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD16 size B16; - CARD16 pad1 B16; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; + CARD8 status; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 size B16; + CARD16 pad1 B16; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; } xRRGetCrtcGammaSizeReply; + #define sz_xRRGetCrtcGammaSizeReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RRCrtc crtc B32; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RRCrtc crtc B32; } xRRGetCrtcGammaReq; + #define sz_xRRGetCrtcGammaReq 8 typedef struct { - BYTE type; - CARD8 status; - CARD16 sequenceNumber B16; - CARD32 length B32; - CARD16 size B16; - CARD16 pad1 B16; - CARD32 pad2 B32; - CARD32 pad3 B32; - CARD32 pad4 B32; - CARD32 pad5 B32; - CARD32 pad6 B32; + BYTE type; + CARD8 status; + CARD16 sequenceNumber B16; + CARD32 length B32; + CARD16 size B16; + CARD16 pad1 B16; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; + CARD32 pad5 B32; + CARD32 pad6 B32; } xRRGetCrtcGammaReply; + #define sz_xRRGetCrtcGammaReply 32 typedef struct { - CARD8 reqType; - CARD8 randrReqType; - CARD16 length B16; - RRCrtc crtc B32; - CARD16 size B16; - CARD16 pad1 B16; + CARD8 reqType; + CARD8 randrReqType; + CARD16 length B16; + RRCrtc crtc B32; + CARD16 size B16; + CARD16 pad1 B16; } xRRSetCrtcGammaReq; + #define sz_xRRSetCrtcGammaReq 12 /* * event */ typedef struct { - CARD8 type; /* always evBase + ScreenChangeNotify */ - CARD8 rotation; /* new rotation */ + CARD8 type; /* always evBase + ScreenChangeNotify */ + CARD8 rotation; /* new rotation */ CARD16 sequenceNumber B16; - Time timestamp B32; /* time screen was changed */ - Time configTimestamp B32; /* time config data was changed */ - Window root B32; /* root window */ - Window window B32; /* window requesting notification */ - SizeID sizeID B16; /* new size ID */ - CARD16 subpixelOrder B16; /* subpixel order */ - CARD16 widthInPixels B16; /* new size */ + Time timestamp B32; /* time screen was changed */ + Time configTimestamp B32; /* time config data was changed */ + Window root B32; /* root window */ + Window window B32; /* window requesting notification */ + SizeID sizeID B16; /* new size ID */ + CARD16 subpixelOrder B16; /* subpixel order */ + CARD16 widthInPixels B16; /* new size */ CARD16 heightInPixels B16; CARD16 widthInMillimeters B16; CARD16 heightInMillimeters B16; } xRRScreenChangeNotifyEvent; + #define sz_xRRScreenChangeNotifyEvent 32 typedef struct { - CARD8 type; /* always evBase + RRNotify */ - CARD8 subCode; /* RRNotify_CrtcChange */ + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_CrtcChange */ CARD16 sequenceNumber B16; - Time timestamp B32; /* time crtc was changed */ - Window window B32; /* window requesting notification */ - RRCrtc crtc B32; /* affected CRTC */ - RRMode mode B32; /* current mode */ - CARD16 rotation B16; /* rotation and reflection */ - CARD16 pad1 B16; /* unused */ - INT16 x B16; /* new location */ + Time timestamp B32; /* time crtc was changed */ + Window window B32; /* window requesting notification */ + RRCrtc crtc B32; /* affected CRTC */ + RRMode mode B32; /* current mode */ + CARD16 rotation B16; /* rotation and reflection */ + CARD16 pad1 B16; /* unused */ + INT16 x B16; /* new location */ INT16 y B16; - CARD16 width B16; /* new size */ + CARD16 width B16; /* new size */ CARD16 height B16; } xRRCrtcChangeNotifyEvent; + #define sz_xRRCrtcChangeNotifyEvent 32 typedef struct { - CARD8 type; /* always evBase + RRNotify */ - CARD8 subCode; /* RRNotify_OutputChange */ + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_OutputChange */ CARD16 sequenceNumber B16; - Time timestamp B32; /* time crtc was changed */ - Time configTimestamp B32; /* time crtc was changed */ - Window window B32; /* window requesting notification */ - RROutput output B32; /* affected output */ - RRCrtc crtc B32; /* current crtc */ - RRMode mode B32; /* current mode */ - CARD16 rotation B16; /* rotation and reflection */ - CARD8 connection; /* connection status */ - CARD8 subpixelOrder; /* subpixel order */ + Time timestamp B32; /* time crtc was changed */ + Time configTimestamp B32; /* time crtc was changed */ + Window window B32; /* window requesting notification */ + RROutput output B32; /* affected output */ + RRCrtc crtc B32; /* current crtc */ + RRMode mode B32; /* current mode */ + CARD16 rotation B16; /* rotation and reflection */ + CARD8 connection; /* connection status */ + CARD8 subpixelOrder; /* subpixel order */ } xRROutputChangeNotifyEvent; + #define sz_xRROutputChangeNotifyEvent 32 typedef struct { - CARD8 type; /* always evBase + RRNotify */ - CARD8 subCode; /* RRNotify_OutputProperty */ + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_OutputProperty */ CARD16 sequenceNumber B16; - Window window B32; /* window requesting notification */ - RROutput output B32; /* affected output */ - Atom atom B32; /* property name */ - Time timestamp B32; /* time crtc was changed */ - CARD8 state; /* NewValue or Deleted */ + Window window B32; /* window requesting notification */ + RROutput output B32; /* affected output */ + Atom atom B32; /* property name */ + Time timestamp B32; /* time crtc was changed */ + CARD8 state; /* NewValue or Deleted */ CARD8 pad1; CARD16 pad2 B16; CARD32 pad3 B32; CARD32 pad4 B32; } xRROutputPropertyNotifyEvent; + #define sz_xRROutputPropertyNotifyEvent 32 #undef RRModeFlags @@ -652,4 +695,4 @@ typedef struct { #undef SizeID #undef SubpixelOrder -#endif /* _XRANDRP_H_ */ +#endif /* _XRANDRP_H_ */ diff --git a/nx-X11/programs/Xserver/randr/randrstr.h b/nx-X11/programs/Xserver/randr/randrstr.h index 620972d63..8e9107c9f 100644 --- a/nx-X11/programs/Xserver/randr/randrstr.h +++ b/nx-X11/programs/Xserver/randr/randrstr.h @@ -51,7 +51,7 @@ #include "randrproto.h" #endif #ifdef RENDER -#include /* we share subpixel order information */ +#include /* we share subpixel order information */ #include "picturestr.h" #endif #include @@ -60,153 +60,147 @@ #define RANDR_10_INTERFACE 1 #define RANDR_12_INTERFACE 1 -typedef XID RRMode; -typedef XID RROutput; -typedef XID RRCrtc; +typedef XID RRMode; +typedef XID RROutput; +typedef XID RRCrtc; -extern int RREventBase, RRErrorBase; +extern int RREventBase, RRErrorBase; -extern int (*ProcRandrVector[RRNumberRequests])(ClientPtr); -extern int (*SProcRandrVector[RRNumberRequests])(ClientPtr); +extern int (*ProcRandrVector[RRNumberRequests]) (ClientPtr); +extern int (*SProcRandrVector[RRNumberRequests]) (ClientPtr); /* * Modeline for a monitor. Name follows directly after this struct */ #define RRModeName(pMode) ((char *) (pMode + 1)) -typedef struct _rrMode RRModeRec, *RRModePtr; -typedef struct _rrPropertyValue RRPropertyValueRec, *RRPropertyValuePtr; -typedef struct _rrProperty RRPropertyRec, *RRPropertyPtr; -typedef struct _rrCrtc RRCrtcRec, *RRCrtcPtr; -typedef struct _rrOutput RROutputRec, *RROutputPtr; +typedef struct _rrMode RRModeRec, *RRModePtr; +typedef struct _rrPropertyValue RRPropertyValueRec, *RRPropertyValuePtr; +typedef struct _rrProperty RRPropertyRec, *RRPropertyPtr; +typedef struct _rrCrtc RRCrtcRec, *RRCrtcPtr; +typedef struct _rrOutput RROutputRec, *RROutputPtr; struct _rrMode { - int refcnt; - xRRModeInfo mode; - char *name; - ScreenPtr userScreen; + int refcnt; + xRRModeInfo mode; + char *name; + ScreenPtr userScreen; }; struct _rrPropertyValue { - Atom type; /* ignored by server */ - short format; /* format of data for swapping - 8,16,32 */ - long size; /* size of data in (format/8) bytes */ - void *data; /* private to client */ + Atom type; /* ignored by server */ + short format; /* format of data for swapping - 8,16,32 */ + long size; /* size of data in (format/8) bytes */ + void *data; /* private to client */ }; struct _rrProperty { - RRPropertyPtr next; - ATOM propertyName; - Bool is_pending; - Bool range; - Bool immutable; - int num_valid; - INT32 *valid_values; - RRPropertyValueRec current, pending; + RRPropertyPtr next; + ATOM propertyName; + Bool is_pending; + Bool range; + Bool immutable; + int num_valid; + INT32 *valid_values; + RRPropertyValueRec current, pending; }; struct _rrCrtc { - RRCrtc id; - ScreenPtr pScreen; - RRModePtr mode; - int x, y; - Rotation rotation; - Rotation rotations; - Bool changed; - int numOutputs; - RROutputPtr *outputs; - int gammaSize; - CARD16 *gammaRed; - CARD16 *gammaBlue; - CARD16 *gammaGreen; - void *devPrivate; + RRCrtc id; + ScreenPtr pScreen; + RRModePtr mode; + int x, y; + Rotation rotation; + Rotation rotations; + Bool changed; + int numOutputs; + RROutputPtr *outputs; + int gammaSize; + CARD16 *gammaRed; + CARD16 *gammaBlue; + CARD16 *gammaGreen; + void *devPrivate; }; struct _rrOutput { - RROutput id; - ScreenPtr pScreen; - char *name; - int nameLength; - CARD8 connection; - CARD8 subpixelOrder; - int mmWidth; - int mmHeight; - RRCrtcPtr crtc; - int numCrtcs; - RRCrtcPtr *crtcs; - int numClones; - RROutputPtr *clones; - int numModes; - int numPreferred; - RRModePtr *modes; - int numUserModes; - RRModePtr *userModes; - Bool changed; - RRPropertyPtr properties; - Bool pendingProperties; - void *devPrivate; + RROutput id; + ScreenPtr pScreen; + char *name; + int nameLength; + CARD8 connection; + CARD8 subpixelOrder; + int mmWidth; + int mmHeight; + RRCrtcPtr crtc; + int numCrtcs; + RRCrtcPtr *crtcs; + int numClones; + RROutputPtr *clones; + int numModes; + int numPreferred; + RRModePtr *modes; + int numUserModes; + RRModePtr *userModes; + Bool changed; + RRPropertyPtr properties; + Bool pendingProperties; + void *devPrivate; }; #if RANDR_12_INTERFACE -typedef Bool (*RRScreenSetSizeProcPtr) (ScreenPtr pScreen, - CARD16 width, - CARD16 height, - CARD32 mmWidth, - CARD32 mmHeight); - -typedef Bool (*RRCrtcSetProcPtr) (ScreenPtr pScreen, - RRCrtcPtr crtc, - RRModePtr mode, - int x, - int y, - Rotation rotation, - int numOutputs, - RROutputPtr *outputs); - -typedef Bool (*RRCrtcSetGammaProcPtr) (ScreenPtr pScreen, - RRCrtcPtr crtc); - -typedef Bool (*RROutputSetPropertyProcPtr) (ScreenPtr pScreen, - RROutputPtr output, - Atom property, - RRPropertyValuePtr value); - -typedef Bool (*RROutputValidateModeProcPtr) (ScreenPtr pScreen, - RROutputPtr output, - RRModePtr mode); - -typedef void (*RRModeDestroyProcPtr) (ScreenPtr pScreen, - RRModePtr mode); +typedef Bool (*RRScreenSetSizeProcPtr) (ScreenPtr pScreen, + CARD16 width, + CARD16 height, + CARD32 mmWidth, CARD32 mmHeight); + +typedef Bool (*RRCrtcSetProcPtr) (ScreenPtr pScreen, + RRCrtcPtr crtc, + RRModePtr mode, + int x, + int y, + Rotation rotation, + int numOutputs, RROutputPtr * outputs); + +typedef Bool (*RRCrtcSetGammaProcPtr) (ScreenPtr pScreen, RRCrtcPtr crtc); + +typedef Bool (*RROutputSetPropertyProcPtr) (ScreenPtr pScreen, + RROutputPtr output, + Atom property, + RRPropertyValuePtr value); + +typedef Bool (*RROutputValidateModeProcPtr) (ScreenPtr pScreen, + RROutputPtr output, + RRModePtr mode); + +typedef void (*RRModeDestroyProcPtr) (ScreenPtr pScreen, RRModePtr mode); #endif -typedef Bool (*RRGetInfoProcPtr) (ScreenPtr pScreen, Rotation *rotations); -typedef Bool (*RRCloseScreenProcPtr) ( int i, ScreenPtr pscreen); +typedef Bool (*RRGetInfoProcPtr) (ScreenPtr pScreen, Rotation * rotations); +typedef Bool (*RRCloseScreenProcPtr) (int i, ScreenPtr pscreen); /* These are for 1.0 compatibility */ typedef struct _rrRefresh { - CARD16 rate; - RRModePtr mode; + CARD16 rate; + RRModePtr mode; } RRScreenRate, *RRScreenRatePtr; typedef struct _rrScreenSize { - int id; - short width, height; - short mmWidth, mmHeight; - int nRates; + int id; + short width, height; + short mmWidth, mmHeight; + int nRates; RRScreenRatePtr pRates; } RRScreenSize, *RRScreenSizePtr; #ifdef RANDR_10_INTERFACE -typedef Bool (*RRSetConfigProcPtr) (ScreenPtr pScreen, - Rotation rotation, - int rate, - RRScreenSizePtr pSize); +typedef Bool (*RRSetConfigProcPtr) (ScreenPtr pScreen, + Rotation rotation, + int rate, RRScreenSizePtr pSize); #endif - typedef struct _rrScrPriv { /* @@ -214,56 +208,56 @@ typedef struct _rrScrPriv { * as they initialize */ #if RANDR_10_INTERFACE - RRSetConfigProcPtr rrSetConfig; + RRSetConfigProcPtr rrSetConfig; #endif - RRGetInfoProcPtr rrGetInfo; + RRGetInfoProcPtr rrGetInfo; #if RANDR_12_INTERFACE - RRScreenSetSizeProcPtr rrScreenSetSize; - RRCrtcSetProcPtr rrCrtcSet; - RRCrtcSetGammaProcPtr rrCrtcSetGamma; - RROutputSetPropertyProcPtr rrOutputSetProperty; - RROutputValidateModeProcPtr rrOutputValidateMode; - RRModeDestroyProcPtr rrModeDestroy; + RRScreenSetSizeProcPtr rrScreenSetSize; + RRCrtcSetProcPtr rrCrtcSet; + RRCrtcSetGammaProcPtr rrCrtcSetGamma; + RROutputSetPropertyProcPtr rrOutputSetProperty; + RROutputValidateModeProcPtr rrOutputValidateMode; + RRModeDestroyProcPtr rrModeDestroy; #endif /* * Private part of the structure; not considered part of the ABI */ - TimeStamp lastSetTime; /* last changed by client */ - TimeStamp lastConfigTime; /* possible configs changed */ - RRCloseScreenProcPtr CloseScreen; + TimeStamp lastSetTime; /* last changed by client */ + TimeStamp lastConfigTime; /* possible configs changed */ + RRCloseScreenProcPtr CloseScreen; - Bool changed; /* some config changed */ - Bool configChanged; /* configuration changed */ - Bool layoutChanged; /* screen layout changed */ + Bool changed; /* some config changed */ + Bool configChanged; /* configuration changed */ + Bool layoutChanged; /* screen layout changed */ - CARD16 minWidth, minHeight; - CARD16 maxWidth, maxHeight; - CARD16 width, height; /* last known screen size */ - CARD16 mmWidth, mmHeight; /* last known screen size */ + CARD16 minWidth, minHeight; + CARD16 maxWidth, maxHeight; + CARD16 width, height; /* last known screen size */ + CARD16 mmWidth, mmHeight; /* last known screen size */ - int numOutputs; - RROutputPtr *outputs; + int numOutputs; + RROutputPtr *outputs; - int numCrtcs; - RRCrtcPtr *crtcs; + int numCrtcs; + RRCrtcPtr *crtcs; /* Last known pointer position */ - RRCrtcPtr pointerCrtc; + RRCrtcPtr pointerCrtc; #ifdef RANDR_10_INTERFACE /* * Configuration information */ - Rotation rotations; - CARD16 reqWidth, reqHeight; + Rotation rotations; + CARD16 reqWidth, reqHeight; - int nSizes; - RRScreenSizePtr pSizes; + int nSizes; + RRScreenSizePtr pSizes; - Rotation rotation; - int rate; - int size; + Rotation rotation; + int rate; + int size; #endif } rrScrPrivRec, *rrScrPrivPtr; @@ -298,31 +292,32 @@ extern int rrPrivIndex; typedef struct _RREvent *RREventPtr; typedef struct _RREvent { - RREventPtr next; - ClientPtr client; - WindowPtr window; - XID clientResource; - int mask; + RREventPtr next; + ClientPtr client; + WindowPtr window; + XID clientResource; + int mask; } RREventRec; typedef struct _RRTimes { - TimeStamp setTime; - TimeStamp configTime; + TimeStamp setTime; + TimeStamp configTime; } RRTimesRec, *RRTimesPtr; typedef struct _RRClient { - int major_version; - int minor_version; + int major_version; + int minor_version; /* RRTimesRec times[0]; */ } RRClientRec, *RRClientPtr; -extern RESTYPE RRClientType, RREventType; /* resource types for event masks */ +extern RESTYPE RRClientType, RREventType; /* resource types for event masks */ + #ifndef NXAGENT_SERVER extern DevPrivateKey RRClientPrivateKey; #else -extern int RRClientPrivateIndex; +extern int RRClientPrivateIndex; #endif -extern RESTYPE RRCrtcType, RRModeType, RROutputType; +extern RESTYPE RRCrtcType, RRModeType, RROutputType; #define LookupOutput(client,id,a) ((RROutputPtr) \ (SecurityLookupIDByType (client, id, \ @@ -352,18 +347,17 @@ extern RESTYPE RRCrtcType, RRModeType, RROutputType; /* Initialize the extension */ void -RRExtensionInit (void); + RRExtensionInit(void); #ifdef RANDR_12_INTERFACE /* * Set the range of sizes for the screen */ void -RRScreenSetSizeRange (ScreenPtr pScreen, - CARD16 minWidth, - CARD16 minHeight, - CARD16 maxWidth, - CARD16 maxHeight); + +RRScreenSetSizeRange(ScreenPtr pScreen, + CARD16 minWidth, + CARD16 minHeight, CARD16 maxWidth, CARD16 maxHeight); #endif /* rrscreen.c */ @@ -373,110 +367,101 @@ RRScreenSetSizeRange (ScreenPtr pScreen, * the size of the screen */ void -RRScreenSizeNotify (ScreenPtr pScreen); + RRScreenSizeNotify(ScreenPtr pScreen); /* * Request that the screen be resized */ Bool -RRScreenSizeSet (ScreenPtr pScreen, - CARD16 width, - CARD16 height, - CARD32 mmWidth, - CARD32 mmHeight); + +RRScreenSizeSet(ScreenPtr pScreen, + CARD16 width, CARD16 height, CARD32 mmWidth, CARD32 mmHeight); /* * Send ConfigureNotify event to root window when 'something' happens */ void -RRSendConfigNotify (ScreenPtr pScreen); + RRSendConfigNotify(ScreenPtr pScreen); /* * screen dispatch */ int -ProcRRGetScreenSizeRange (ClientPtr client); + ProcRRGetScreenSizeRange(ClientPtr client); int -ProcRRSetScreenSize (ClientPtr client); + ProcRRSetScreenSize(ClientPtr client); int -ProcRRGetScreenResources (ClientPtr client); + ProcRRGetScreenResources(ClientPtr client); int -ProcRRSetScreenConfig (ClientPtr client); + ProcRRSetScreenConfig(ClientPtr client); int -ProcRRGetScreenInfo (ClientPtr client); + ProcRRGetScreenInfo(ClientPtr client); /* * Deliver a ScreenNotify event */ void -RRDeliverScreenEvent (ClientPtr client, WindowPtr pWin, ScreenPtr pScreen); + RRDeliverScreenEvent(ClientPtr client, WindowPtr pWin, ScreenPtr pScreen); /* mirandr.c */ Bool -miRandRInit (ScreenPtr pScreen); + miRandRInit(ScreenPtr pScreen); Bool -miRRGetInfo (ScreenPtr pScreen, Rotation *rotations); + miRRGetInfo(ScreenPtr pScreen, Rotation * rotations); Bool -miRRGetScreenInfo (ScreenPtr pScreen); + miRRGetScreenInfo(ScreenPtr pScreen); Bool -miRRCrtcSet (ScreenPtr pScreen, - RRCrtcPtr crtc, - RRModePtr mode, - int x, - int y, - Rotation rotation, - int numOutput, - RROutputPtr *outputs); + +miRRCrtcSet(ScreenPtr pScreen, + RRCrtcPtr crtc, + RRModePtr mode, + int x, + int y, Rotation rotation, int numOutput, RROutputPtr * outputs); Bool -miRROutputSetProperty (ScreenPtr pScreen, - RROutputPtr output, - Atom property, - RRPropertyValuePtr value); + +miRROutputSetProperty(ScreenPtr pScreen, + RROutputPtr output, + Atom property, RRPropertyValuePtr value); Bool -miRROutputValidateMode (ScreenPtr pScreen, - RROutputPtr output, - RRModePtr mode); + miRROutputValidateMode(ScreenPtr pScreen, RROutputPtr output, RRModePtr mode); void -miRRModeDestroy (ScreenPtr pScreen, - RRModePtr mode); + miRRModeDestroy(ScreenPtr pScreen, RRModePtr mode); /* randr.c */ /* * Send all pending events */ void -RRTellChanged (ScreenPtr pScreen); + RRTellChanged(ScreenPtr pScreen); /* * Poll the driver for changed information */ Bool -RRGetInfo (ScreenPtr pScreen); + RRGetInfo(ScreenPtr pScreen); -Bool RRInit (void); +Bool RRInit(void); Bool RRScreenInit(ScreenPtr pScreen); -RROutputPtr -RRFirstOutput (ScreenPtr pScreen); +RROutputPtr RRFirstOutput(ScreenPtr pScreen); -Rotation -RRGetRotation (ScreenPtr pScreen); +Rotation RRGetRotation(ScreenPtr pScreen); CARD16 -RRVerticalRefresh (xRRModeInfo *mode); + RRVerticalRefresh(xRRModeInfo * mode); -#ifdef RANDR_10_INTERFACE +#ifdef RANDR_10_INTERFACE /* * This is the old interface, deprecated but left * around for compatibility @@ -487,38 +472,30 @@ RRVerticalRefresh (xRRModeInfo *mode); */ RRScreenSizePtr -RRRegisterSize (ScreenPtr pScreen, - short width, - short height, - short mmWidth, - short mmHeight); +RRRegisterSize(ScreenPtr pScreen, + short width, short height, short mmWidth, short mmHeight); -Bool RRRegisterRate (ScreenPtr pScreen, - RRScreenSizePtr pSize, - int rate); +Bool RRRegisterRate(ScreenPtr pScreen, RRScreenSizePtr pSize, int rate); /* * Finally, set the current configuration of the screen */ void -RRSetCurrentConfig (ScreenPtr pScreen, - Rotation rotation, - int rate, - RRScreenSizePtr pSize); -Bool RRScreenInit (ScreenPtr pScreen); +RRSetCurrentConfig(ScreenPtr pScreen, + Rotation rotation, int rate, RRScreenSizePtr pSize); + +Bool RRScreenInit(ScreenPtr pScreen); -Rotation -RRGetRotation (ScreenPtr pScreen); +Rotation RRGetRotation(ScreenPtr pScreen); int -RRSetScreenConfig (ScreenPtr pScreen, - Rotation rotation, - int rate, - RRScreenSizePtr pSize); -#endif +RRSetScreenConfig(ScreenPtr pScreen, + Rotation rotation, int rate, RRScreenSizePtr pSize); + +#endif /* rrcrtc.c */ @@ -527,57 +504,49 @@ RRSetScreenConfig (ScreenPtr pScreen, * some position or size element changed */ void -RRCrtcChanged (RRCrtcPtr crtc, Bool layoutChanged); + RRCrtcChanged(RRCrtcPtr crtc, Bool layoutChanged); /* * Create a CRTC */ -RRCrtcPtr -RRCrtcCreate (ScreenPtr pScreen, void *devPrivate); +RRCrtcPtr RRCrtcCreate(ScreenPtr pScreen, void *devPrivate); /* * Set the allowed rotations on a CRTC */ void -RRCrtcSetRotations (RRCrtcPtr crtc, Rotation rotations); + RRCrtcSetRotations(RRCrtcPtr crtc, Rotation rotations); /* * Notify the extension that the Crtc has been reconfigured, * the driver calls this whenever it has updated the mode */ Bool -RRCrtcNotify (RRCrtcPtr crtc, - RRModePtr mode, - int x, - int y, - Rotation rotation, - int numOutputs, - RROutputPtr *outputs); + +RRCrtcNotify(RRCrtcPtr crtc, + RRModePtr mode, + int x, + int y, Rotation rotation, int numOutputs, RROutputPtr * outputs); void -RRDeliverCrtcEvent (ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc); + RRDeliverCrtcEvent(ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc); /* * Request that the Crtc be reconfigured */ Bool -RRCrtcSet (RRCrtcPtr crtc, - RRModePtr mode, - int x, - int y, - Rotation rotation, - int numOutput, - RROutputPtr *outputs); + +RRCrtcSet(RRCrtcPtr crtc, + RRModePtr mode, + int x, + int y, Rotation rotation, int numOutput, RROutputPtr * outputs); /* * Request that the Crtc gamma be changed */ Bool -RRCrtcGammaSet (RRCrtcPtr crtc, - CARD16 *red, - CARD16 *green, - CARD16 *blue); + RRCrtcGammaSet(RRCrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue); /* * Notify the extension that the Crtc gamma has been changed @@ -586,15 +555,14 @@ RRCrtcGammaSet (RRCrtcPtr crtc, */ Bool -RRCrtcGammaNotify (RRCrtcPtr crtc); + RRCrtcGammaNotify(RRCrtcPtr crtc); /* * Set the size of the gamma table at server startup time */ Bool -RRCrtcGammaSetSize (RRCrtcPtr crtc, - int size); + RRCrtcGammaSetSize(RRCrtcPtr crtc, int size); /* * Return the area of the frame buffer scanned out by the crtc, @@ -602,85 +570,82 @@ RRCrtcGammaSetSize (RRCrtcPtr crtc, */ void -RRCrtcGetScanoutSize(RRCrtcPtr crtc, int *width, int *height); + RRCrtcGetScanoutSize(RRCrtcPtr crtc, int *width, int *height); /* * Destroy a Crtc at shutdown */ void -RRCrtcDestroy (RRCrtcPtr crtc); + RRCrtcDestroy(RRCrtcPtr crtc); /* * Initialize crtc type */ Bool -RRCrtcInit (void); + RRCrtcInit(void); /* * Crtc dispatch */ int -ProcRRGetCrtcInfo (ClientPtr client); + ProcRRGetCrtcInfo(ClientPtr client); int -ProcRRSetCrtcConfig (ClientPtr client); + ProcRRSetCrtcConfig(ClientPtr client); int -ProcRRGetCrtcGammaSize (ClientPtr client); + ProcRRGetCrtcGammaSize(ClientPtr client); int -ProcRRGetCrtcGamma (ClientPtr client); + ProcRRGetCrtcGamma(ClientPtr client); int -ProcRRSetCrtcGamma (ClientPtr client); + ProcRRSetCrtcGamma(ClientPtr client); /* rrdispatch.c */ Bool -RRClientKnowsRates (ClientPtr pClient); + RRClientKnowsRates(ClientPtr pClient); /* rrmode.c */ /* * Find, and if necessary, create a mode */ -RRModePtr -RRModeGet (xRRModeInfo *modeInfo, - const char *name); +RRModePtr RRModeGet(xRRModeInfo * modeInfo, const char *name); void -RRModePruneUnused (ScreenPtr pScreen); + RRModePruneUnused(ScreenPtr pScreen); /* * Destroy a mode. */ void -RRModeDestroy (RRModePtr mode); + RRModeDestroy(RRModePtr mode); /* * Return a list of modes that are valid for some output in pScreen */ -RRModePtr * -RRModesForScreen (ScreenPtr pScreen, int *num_ret); +RRModePtr *RRModesForScreen(ScreenPtr pScreen, int *num_ret); /* * Initialize mode type */ Bool -RRModeInit (void); + RRModeInit(void); int -ProcRRCreateMode (ClientPtr client); + ProcRRCreateMode(ClientPtr client); int -ProcRRDestroyMode (ClientPtr client); + ProcRRDestroyMode(ClientPtr client); int -ProcRRAddOutputMode (ClientPtr client); + ProcRRAddOutputMode(ClientPtr client); int -ProcRRDeleteOutputMode (ClientPtr client); + ProcRRDeleteOutputMode(ClientPtr client); /* rroutput.c */ @@ -691,129 +656,117 @@ ProcRRDeleteOutputMode (ClientPtr client); * (which crtc is in use) */ void -RROutputChanged (RROutputPtr output, Bool configChanged); + RROutputChanged(RROutputPtr output, Bool configChanged); /* * Create an output */ RROutputPtr -RROutputCreate (ScreenPtr pScreen, - const char *name, - int nameLength, - void *devPrivate); +RROutputCreate(ScreenPtr pScreen, + const char *name, int nameLength, void *devPrivate); /* * Notify extension that output parameters have been changed */ Bool -RROutputSetClones (RROutputPtr output, - RROutputPtr *clones, - int numClones); + RROutputSetClones(RROutputPtr output, RROutputPtr * clones, int numClones); Bool -RROutputSetModes (RROutputPtr output, - RRModePtr *modes, - int numModes, - int numPreferred); + +RROutputSetModes(RROutputPtr output, + RRModePtr * modes, int numModes, int numPreferred); int -RROutputAddUserMode (RROutputPtr output, - RRModePtr mode); + RROutputAddUserMode(RROutputPtr output, RRModePtr mode); int -RROutputDeleteUserMode (RROutputPtr output, - RRModePtr mode); + RROutputDeleteUserMode(RROutputPtr output, RRModePtr mode); Bool -RROutputSetCrtcs (RROutputPtr output, - RRCrtcPtr *crtcs, - int numCrtcs); + RROutputSetCrtcs(RROutputPtr output, RRCrtcPtr * crtcs, int numCrtcs); Bool -RROutputSetConnection (RROutputPtr output, - CARD8 connection); + RROutputSetConnection(RROutputPtr output, CARD8 connection); Bool -RROutputSetSubpixelOrder (RROutputPtr output, - int subpixelOrder); + RROutputSetSubpixelOrder(RROutputPtr output, int subpixelOrder); Bool -RROutputSetPhysicalSize (RROutputPtr output, - int mmWidth, - int mmHeight); + RROutputSetPhysicalSize(RROutputPtr output, int mmWidth, int mmHeight); void -RRDeliverOutputEvent(ClientPtr client, WindowPtr pWin, RROutputPtr output); + RRDeliverOutputEvent(ClientPtr client, WindowPtr pWin, RROutputPtr output); void -RROutputDestroy (RROutputPtr output); + RROutputDestroy(RROutputPtr output); int -ProcRRGetOutputInfo (ClientPtr client); + ProcRRGetOutputInfo(ClientPtr client); /* * Initialize output type */ Bool -RROutputInit (void); + RROutputInit(void); /* rrpointer.c */ void -RRPointerMoved (ScreenPtr pScreen, int x, int y); + RRPointerMoved(ScreenPtr pScreen, int x, int y); void -RRPointerScreenConfigured (ScreenPtr pScreen); + RRPointerScreenConfigured(ScreenPtr pScreen); /* rrproperty.c */ void -RRDeleteAllOutputProperties (RROutputPtr output); + RRDeleteAllOutputProperties(RROutputPtr output); RRPropertyValuePtr -RRGetOutputProperty (RROutputPtr output, Atom property, Bool pending); +RRGetOutputProperty(RROutputPtr output, Atom property, Bool pending); + +RRPropertyPtr RRQueryOutputProperty(RROutputPtr output, Atom property); -RRPropertyPtr -RRQueryOutputProperty (RROutputPtr output, Atom property); - void -RRDeleteOutputProperty (RROutputPtr output, Atom property); + RRDeleteOutputProperty(RROutputPtr output, Atom property); Bool -RRPostPendingProperties (RROutputPtr output); + RRPostPendingProperties(RROutputPtr output); int -RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type, - int format, int mode, unsigned long len, - void * value, Bool sendevent, Bool pending); + +RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type, + int format, int mode, unsigned long len, + void *value, Bool sendevent, Bool pending); int -RRConfigureOutputProperty (RROutputPtr output, Atom property, - Bool pending, Bool range, Bool immutable, - int num_values, INT32 *values); + +RRConfigureOutputProperty(RROutputPtr output, Atom property, + Bool pending, Bool range, Bool immutable, + int num_values, INT32 *values); int -ProcRRChangeOutputProperty (ClientPtr client); + ProcRRChangeOutputProperty(ClientPtr client); int -ProcRRGetOutputProperty (ClientPtr client); + ProcRRGetOutputProperty(ClientPtr client); int -ProcRRListOutputProperties (ClientPtr client); + ProcRRListOutputProperties(ClientPtr client); int -ProcRRQueryOutputProperty (ClientPtr client); + ProcRRQueryOutputProperty(ClientPtr client); int -ProcRRConfigureOutputProperty (ClientPtr client); + ProcRRConfigureOutputProperty(ClientPtr client); int -ProcRRDeleteOutputProperty (ClientPtr client); + ProcRRDeleteOutputProperty(ClientPtr client); /* rrxinerama.c */ void -RRXineramaExtensionInit(void); + RRXineramaExtensionInit(void); -#endif /* _RANDRSTR_H_ */ +#endif /* _RANDRSTR_H_ */ /* diff --git a/nx-X11/programs/Xserver/randr/registry.h b/nx-X11/programs/Xserver/randr/registry.h index 29e5fdfd3..28b1510f2 100644 --- a/nx-X11/programs/Xserver/randr/registry.h +++ b/nx-X11/programs/Xserver/randr/registry.h @@ -29,7 +29,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * not be a stack variable. */ void RegisterResourceName(RESTYPE type, char *name); -void RegisterExtensionNames(ExtensionEntry *ext); +void RegisterExtensionNames(ExtensionEntry * ext); /* * Lookup functions. The returned string must not be modified or freed. @@ -45,7 +45,7 @@ const char *LookupResourceName(RESTYPE rtype); */ void dixResetRegistry(void); -#else /* XREGISTRY */ +#else /* XREGISTRY */ /* Define calls away when the registry is not being built. */ @@ -60,5 +60,5 @@ void dixResetRegistry(void); #define dixResetRegistry() { ; } -#endif /* XREGISTRY */ -#endif /* DIX_REGISTRY_H */ +#endif /* XREGISTRY */ +#endif /* DIX_REGISTRY_H */ diff --git a/nx-X11/programs/Xserver/randr/rrcrtc.c b/nx-X11/programs/Xserver/randr/rrcrtc.c index 1b898ddfd..76b4c64f9 100644 --- a/nx-X11/programs/Xserver/randr/rrcrtc.c +++ b/nx-X11/programs/Xserver/randr/rrcrtc.c @@ -41,27 +41,26 @@ #include "swaprep.h" #include "registry.h" -RESTYPE RRCrtcType; +RESTYPE RRCrtcType; /* * Notify the CRTC of some change */ void -RRCrtcChanged (RRCrtcPtr crtc, Bool layoutChanged) +RRCrtcChanged(RRCrtcPtr crtc, Bool layoutChanged) { - ScreenPtr pScreen = crtc->pScreen; + ScreenPtr pScreen = crtc->pScreen; crtc->changed = TRUE; - if (pScreen) - { - rrScrPriv(pScreen); + if (pScreen) { + rrScrPriv(pScreen); - pScrPriv->changed = TRUE; - /* - * Send ConfigureNotify on any layout change - */ - if (layoutChanged) - pScrPriv->layoutChanged = TRUE; + pScrPriv->changed = TRUE; + /* + * Send ConfigureNotify on any layout change + */ + if (layoutChanged) + pScrPriv->layoutChanged = TRUE; } } @@ -69,31 +68,31 @@ RRCrtcChanged (RRCrtcPtr crtc, Bool layoutChanged) * Create a CRTC */ RRCrtcPtr -RRCrtcCreate (ScreenPtr pScreen, void *devPrivate) +RRCrtcCreate(ScreenPtr pScreen, void *devPrivate) { - RRCrtcPtr crtc; - RRCrtcPtr *crtcs; - rrScrPrivPtr pScrPriv; + RRCrtcPtr crtc; + RRCrtcPtr *crtcs; + rrScrPrivPtr pScrPriv; if (!RRInit()) - return NULL; + return NULL; pScrPriv = rrGetScrPriv(pScreen); /* make space for the crtc pointer */ if (pScrPriv->numCrtcs) - crtcs = xrealloc (pScrPriv->crtcs, - (pScrPriv->numCrtcs + 1) * sizeof (RRCrtcPtr)); + crtcs = xrealloc(pScrPriv->crtcs, + (pScrPriv->numCrtcs + 1) * sizeof(RRCrtcPtr)); else - crtcs = xalloc (sizeof (RRCrtcPtr)); + crtcs = xalloc(sizeof(RRCrtcPtr)); if (!crtcs) - return FALSE; + return FALSE; pScrPriv->crtcs = crtcs; - crtc = xcalloc (1, sizeof (RRCrtcRec)); + crtc = xcalloc(1, sizeof(RRCrtcRec)); if (!crtc) - return NULL; - crtc->id = FakeClientID (0); + return NULL; + crtc->id = FakeClientID(0); crtc->pScreen = pScreen; crtc->mode = NULL; crtc->x = 0; @@ -107,8 +106,8 @@ RRCrtcCreate (ScreenPtr pScreen, void *devPrivate) crtc->changed = FALSE; crtc->devPrivate = devPrivate; - if (!AddResource (crtc->id, RRCrtcType, (void *) crtc)) - return NULL; + if (!AddResource(crtc->id, RRCrtcType, (void *) crtc)) + return NULL; /* attach the screen and crtc together */ crtc->pScreen = pScreen; @@ -121,7 +120,7 @@ RRCrtcCreate (ScreenPtr pScreen, void *devPrivate) * Set the allowed rotations on a CRTC */ void -RRCrtcSetRotations (RRCrtcPtr crtc, Rotation rotations) +RRCrtcSetRotations(RRCrtcPtr crtc, Rotation rotations) { crtc->rotations = rotations; } @@ -131,116 +130,103 @@ RRCrtcSetRotations (RRCrtcPtr crtc, Rotation rotations) * the driver calls this whenever it has updated the mode */ Bool -RRCrtcNotify (RRCrtcPtr crtc, - RRModePtr mode, - int x, - int y, - Rotation rotation, - int numOutputs, - RROutputPtr *outputs) +RRCrtcNotify(RRCrtcPtr crtc, + RRModePtr mode, + int x, + int y, Rotation rotation, int numOutputs, RROutputPtr * outputs) { - int i, j; + int i, j; /* * Check to see if any of the new outputs were * not in the old list and mark them as changed */ - for (i = 0; i < numOutputs; i++) - { - for (j = 0; j < crtc->numOutputs; j++) - if (outputs[i] == crtc->outputs[j]) - break; - if (j == crtc->numOutputs) - { - outputs[i]->crtc = crtc; - RROutputChanged (outputs[i], FALSE); - RRCrtcChanged (crtc, FALSE); - } + for (i = 0; i < numOutputs; i++) { + for (j = 0; j < crtc->numOutputs; j++) + if (outputs[i] == crtc->outputs[j]) + break; + if (j == crtc->numOutputs) { + outputs[i]->crtc = crtc; + RROutputChanged(outputs[i], FALSE); + RRCrtcChanged(crtc, FALSE); + } } /* * Check to see if any of the old outputs are * not in the new list and mark them as changed */ - for (j = 0; j < crtc->numOutputs; j++) - { - for (i = 0; i < numOutputs; i++) - if (outputs[i] == crtc->outputs[j]) - break; - if (i == numOutputs) - { - if (crtc->outputs[j]->crtc == crtc) - crtc->outputs[j]->crtc = NULL; - RROutputChanged (crtc->outputs[j], FALSE); - RRCrtcChanged (crtc, FALSE); - } + for (j = 0; j < crtc->numOutputs; j++) { + for (i = 0; i < numOutputs; i++) + if (outputs[i] == crtc->outputs[j]) + break; + if (i == numOutputs) { + if (crtc->outputs[j]->crtc == crtc) + crtc->outputs[j]->crtc = NULL; + RROutputChanged(crtc->outputs[j], FALSE); + RRCrtcChanged(crtc, FALSE); + } } /* * Reallocate the crtc output array if necessary */ - if (numOutputs != crtc->numOutputs) - { - RROutputPtr *newoutputs; - - if (numOutputs) - { - if (crtc->numOutputs) - newoutputs = xrealloc (crtc->outputs, - numOutputs * sizeof (RROutputPtr)); - else - newoutputs = xalloc (numOutputs * sizeof (RROutputPtr)); - if (!newoutputs) - return FALSE; - } - else - { - if (crtc->outputs) - xfree (crtc->outputs); - newoutputs = NULL; - } - crtc->outputs = newoutputs; - crtc->numOutputs = numOutputs; + if (numOutputs != crtc->numOutputs) { + RROutputPtr *newoutputs; + + if (numOutputs) { + if (crtc->numOutputs) + newoutputs = xrealloc(crtc->outputs, + numOutputs * sizeof(RROutputPtr)); + else + newoutputs = xalloc(numOutputs * sizeof(RROutputPtr)); + if (!newoutputs) + return FALSE; + } + else { + if (crtc->outputs) + xfree(crtc->outputs); + newoutputs = NULL; + } + crtc->outputs = newoutputs; + crtc->numOutputs = numOutputs; } /* * Copy the new list of outputs into the crtc */ - memcpy (crtc->outputs, outputs, numOutputs * sizeof (RROutputPtr)); + memcpy(crtc->outputs, outputs, numOutputs * sizeof(RROutputPtr)); /* * Update remaining crtc fields */ - if (mode != crtc->mode) - { - if (crtc->mode) - RRModeDestroy (crtc->mode); - crtc->mode = mode; - if (mode != NULL) - mode->refcnt++; - RRCrtcChanged (crtc, TRUE); - } - if (x != crtc->x) - { - crtc->x = x; - RRCrtcChanged (crtc, TRUE); - } - if (y != crtc->y) - { - crtc->y = y; - RRCrtcChanged (crtc, TRUE); - } - if (rotation != crtc->rotation) - { - crtc->rotation = rotation; - RRCrtcChanged (crtc, TRUE); + if (mode != crtc->mode) { + if (crtc->mode) + RRModeDestroy(crtc->mode); + crtc->mode = mode; + if (mode != NULL) + mode->refcnt++; + RRCrtcChanged(crtc, TRUE); + } + if (x != crtc->x) { + crtc->x = x; + RRCrtcChanged(crtc, TRUE); + } + if (y != crtc->y) { + crtc->y = y; + RRCrtcChanged(crtc, TRUE); + } + if (rotation != crtc->rotation) { + crtc->rotation = rotation; + RRCrtcChanged(crtc, TRUE); } return TRUE; } void -RRDeliverCrtcEvent (ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc) +RRDeliverCrtcEvent(ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc) { ScreenPtr pScreen = pWin->drawable.pScreen; - rrScrPriv (pScreen); - xRRCrtcChangeNotifyEvent ce; - RRModePtr mode = crtc->mode; + + rrScrPriv(pScreen); + xRRCrtcChangeNotifyEvent ce; + RRModePtr mode = crtc->mode; ce.type = RRNotify + RREventBase; ce.subCode = RRNotify_CrtcChange; @@ -249,37 +235,36 @@ RRDeliverCrtcEvent (ClientPtr client, WindowPtr pWin, RRCrtcPtr crtc) ce.window = pWin->drawable.id; ce.crtc = crtc->id; ce.rotation = crtc->rotation; - if (mode) - { - ce.mode = mode->mode.id; - ce.x = crtc->x; - ce.y = crtc->y; - ce.width = mode->mode.width; - ce.height = mode->mode.height; - } - else - { - ce.mode = None; - ce.x = 0; - ce.y = 0; - ce.width = 0; - ce.height = 0; - } - WriteEventsToClient (client, 1, (xEvent *) &ce); + if (mode) { + ce.mode = mode->mode.id; + ce.x = crtc->x; + ce.y = crtc->y; + ce.width = mode->mode.width; + ce.height = mode->mode.height; + } + else { + ce.mode = None; + ce.x = 0; + ce.y = 0; + ce.width = 0; + ce.height = 0; + } + WriteEventsToClient(client, 1, (xEvent *) &ce); } static Bool -RRCrtcPendingProperties (RRCrtcPtr crtc) +RRCrtcPendingProperties(RRCrtcPtr crtc) { - ScreenPtr pScreen = crtc->pScreen; + ScreenPtr pScreen = crtc->pScreen; + rrScrPriv(pScreen); - int o; + int o; + + for (o = 0; o < pScrPriv->numOutputs; o++) { + RROutputPtr output = pScrPriv->outputs[o]; - for (o = 0; o < pScrPriv->numOutputs; o++) - { - RROutputPtr output = pScrPriv->outputs[o]; - if (output->crtc == crtc && output->pendingProperties) - return TRUE; + if (output->crtc == crtc && output->pendingProperties) + return TRUE; } return FALSE; } @@ -288,89 +273,80 @@ RRCrtcPendingProperties (RRCrtcPtr crtc) * Request that the Crtc be reconfigured */ Bool -RRCrtcSet (RRCrtcPtr crtc, - RRModePtr mode, - int x, - int y, - Rotation rotation, - int numOutputs, - RROutputPtr *outputs) +RRCrtcSet(RRCrtcPtr crtc, + RRModePtr mode, + int x, + int y, Rotation rotation, int numOutputs, RROutputPtr * outputs) { - ScreenPtr pScreen = crtc->pScreen; - Bool ret = FALSE; + ScreenPtr pScreen = crtc->pScreen; + Bool ret = FALSE; + rrScrPriv(pScreen); /* See if nothing changed */ if (crtc->mode == mode && - crtc->x == x && - crtc->y == y && - crtc->rotation == rotation && - crtc->numOutputs == numOutputs && - !memcmp (crtc->outputs, outputs, numOutputs * sizeof (RROutputPtr)) && - !RRCrtcPendingProperties (crtc)) - { - ret = TRUE; - } - else - { + crtc->x == x && + crtc->y == y && + crtc->rotation == rotation && + crtc->numOutputs == numOutputs && + !memcmp(crtc->outputs, outputs, numOutputs * sizeof(RROutputPtr)) && + !RRCrtcPendingProperties(crtc)) { + ret = TRUE; + } + else { #if RANDR_12_INTERFACE - if (pScrPriv->rrCrtcSet) - { - ret = (*pScrPriv->rrCrtcSet) (pScreen, crtc, mode, x, y, - rotation, numOutputs, outputs); - } - else + if (pScrPriv->rrCrtcSet) { + ret = (*pScrPriv->rrCrtcSet) (pScreen, crtc, mode, x, y, + rotation, numOutputs, outputs); + } + else #endif - { + { #if RANDR_10_INTERFACE - if (pScrPriv->rrSetConfig) - { - RRScreenSize size; - RRScreenRate rate; - - if (!mode) - { - RRCrtcNotify (crtc, NULL, x, y, rotation, 0, NULL); - ret = TRUE; - } - else - { - size.width = mode->mode.width; - size.height = mode->mode.height; - if (outputs[0]->mmWidth && outputs[0]->mmHeight) - { - size.mmWidth = outputs[0]->mmWidth; - size.mmHeight = outputs[0]->mmHeight; - } - else - { - size.mmWidth = pScreen->mmWidth; - size.mmHeight = pScreen->mmHeight; - } - size.nRates = 1; - rate.rate = RRVerticalRefresh (&mode->mode); - size.pRates = &rate; - ret = (*pScrPriv->rrSetConfig) (pScreen, rotation, rate.rate, &size); - /* - * Old 1.0 interface tied screen size to mode size - */ - if (ret) - { - RRCrtcNotify (crtc, mode, x, y, rotation, 1, outputs); - RRScreenSizeNotify (pScreen); - } - } - } + if (pScrPriv->rrSetConfig) { + RRScreenSize size; + RRScreenRate rate; + + if (!mode) { + RRCrtcNotify(crtc, NULL, x, y, rotation, 0, NULL); + ret = TRUE; + } + else { + size.width = mode->mode.width; + size.height = mode->mode.height; + if (outputs[0]->mmWidth && outputs[0]->mmHeight) { + size.mmWidth = outputs[0]->mmWidth; + size.mmHeight = outputs[0]->mmHeight; + } + else { + size.mmWidth = pScreen->mmWidth; + size.mmHeight = pScreen->mmHeight; + } + size.nRates = 1; + rate.rate = RRVerticalRefresh(&mode->mode); + size.pRates = &rate; + ret = + (*pScrPriv->rrSetConfig) (pScreen, rotation, rate.rate, + &size); + /* + * Old 1.0 interface tied screen size to mode size + */ + if (ret) { + RRCrtcNotify(crtc, mode, x, y, rotation, 1, outputs); + RRScreenSizeNotify(pScreen); + } + } + } #endif - } - if (ret) - { - int o; - RRTellChanged (pScreen); + } + if (ret) { + int o; - for (o = 0; o < numOutputs; o++) - RRPostPendingProperties (outputs[o]); - } + RRTellChanged(pScreen); + + for (o = 0; o < numOutputs; o++) + RRPostPendingProperties(outputs[o]); + } } return ret; } @@ -379,38 +355,35 @@ RRCrtcSet (RRCrtcPtr crtc, * Destroy a Crtc at shutdown */ void -RRCrtcDestroy (RRCrtcPtr crtc) +RRCrtcDestroy(RRCrtcPtr crtc) { - FreeResource (crtc->id, 0); + FreeResource(crtc->id, 0); } static int -RRCrtcDestroyResource (void * value, XID pid) +RRCrtcDestroyResource(void *value, XID pid) { - RRCrtcPtr crtc = (RRCrtcPtr) value; - ScreenPtr pScreen = crtc->pScreen; - - if (pScreen) - { - rrScrPriv(pScreen); - int i; - - for (i = 0; i < pScrPriv->numCrtcs; i++) - { - if (pScrPriv->crtcs[i] == crtc) - { - memmove (pScrPriv->crtcs + i, pScrPriv->crtcs + i + 1, - (pScrPriv->numCrtcs - (i + 1)) * sizeof (RRCrtcPtr)); - --pScrPriv->numCrtcs; - break; - } - } + RRCrtcPtr crtc = (RRCrtcPtr) value; + ScreenPtr pScreen = crtc->pScreen; + + if (pScreen) { + rrScrPriv(pScreen); + int i; + + for (i = 0; i < pScrPriv->numCrtcs; i++) { + if (pScrPriv->crtcs[i] == crtc) { + memmove(pScrPriv->crtcs + i, pScrPriv->crtcs + i + 1, + (pScrPriv->numCrtcs - (i + 1)) * sizeof(RRCrtcPtr)); + --pScrPriv->numCrtcs; + break; + } + } } if (crtc->gammaRed) - xfree (crtc->gammaRed); + xfree(crtc->gammaRed); if (crtc->mode) - RRModeDestroy (crtc->mode); - xfree (crtc); + RRModeDestroy(crtc->mode); + xfree(crtc); return 1; } @@ -419,25 +392,22 @@ RRCrtcDestroyResource (void * value, XID pid) */ Bool -RRCrtcGammaSet (RRCrtcPtr crtc, - CARD16 *red, - CARD16 *green, - CARD16 *blue) +RRCrtcGammaSet(RRCrtcPtr crtc, CARD16 *red, CARD16 *green, CARD16 *blue) { - Bool ret = TRUE; + Bool ret = TRUE; + #if RANDR_12_INTERFACE - ScreenPtr pScreen = crtc->pScreen; + ScreenPtr pScreen = crtc->pScreen; #endif - memcpy (crtc->gammaRed, red, crtc->gammaSize * sizeof (CARD16)); - memcpy (crtc->gammaGreen, green, crtc->gammaSize * sizeof (CARD16)); - memcpy (crtc->gammaBlue, blue, crtc->gammaSize * sizeof (CARD16)); + memcpy(crtc->gammaRed, red, crtc->gammaSize * sizeof(CARD16)); + memcpy(crtc->gammaGreen, green, crtc->gammaSize * sizeof(CARD16)); + memcpy(crtc->gammaBlue, blue, crtc->gammaSize * sizeof(CARD16)); #if RANDR_12_INTERFACE - if (pScreen) - { - rrScrPriv(pScreen); - if (pScrPriv->rrCrtcSetGamma) - ret = (*pScrPriv->rrCrtcSetGamma) (pScreen, crtc); + if (pScreen) { + rrScrPriv(pScreen); + if (pScrPriv->rrCrtcSetGamma) + ret = (*pScrPriv->rrCrtcSetGamma) (pScreen, crtc); } #endif return ret; @@ -450,9 +420,9 @@ RRCrtcGammaSet (RRCrtcPtr crtc, */ Bool -RRCrtcGammaNotify (RRCrtcPtr crtc) +RRCrtcGammaNotify(RRCrtcPtr crtc) { - return TRUE; /* not much going on here */ + return TRUE; /* not much going on here */ } /** @@ -462,22 +432,22 @@ void RRCrtcGetScanoutSize(RRCrtcPtr crtc, int *width, int *height) { if (crtc->mode == NULL) { - *width = 0; - *height = 0; - return; + *width = 0; + *height = 0; + return; } switch (crtc->rotation & 0xf) { case RR_Rotate_0: case RR_Rotate_180: - *width = crtc->mode->mode.width; - *height = crtc->mode->mode.height; - break; + *width = crtc->mode->mode.width; + *height = crtc->mode->mode.height; + break; case RR_Rotate_90: case RR_Rotate_270: - *width = crtc->mode->mode.height; - *height = crtc->mode->mode.width; - break; + *width = crtc->mode->mode.height; + *height = crtc->mode->mode.width; + break; } } @@ -486,26 +456,24 @@ RRCrtcGetScanoutSize(RRCrtcPtr crtc, int *width, int *height) */ Bool -RRCrtcGammaSetSize (RRCrtcPtr crtc, - int size) +RRCrtcGammaSetSize(RRCrtcPtr crtc, int size) { - CARD16 *gamma; + CARD16 *gamma; if (size == crtc->gammaSize) - return TRUE; - if (size) - { - gamma = xalloc (size * 3 * sizeof (CARD16)); - if (!gamma) - return FALSE; + return TRUE; + if (size) { + gamma = xalloc(size * 3 * sizeof(CARD16)); + if (!gamma) + return FALSE; } else - gamma = NULL; + gamma = NULL; if (crtc->gammaRed) - xfree (crtc->gammaRed); + xfree(crtc->gammaRed); crtc->gammaRed = gamma; crtc->gammaGreen = gamma + size; - crtc->gammaBlue = gamma + size*2; + crtc->gammaBlue = gamma + size * 2; crtc->gammaSize = size; return TRUE; } @@ -514,36 +482,36 @@ RRCrtcGammaSetSize (RRCrtcPtr crtc, * Initialize crtc type */ Bool -RRCrtcInit (void) +RRCrtcInit(void) { - RRCrtcType = CreateNewResourceType (RRCrtcDestroyResource); + RRCrtcType = CreateNewResourceType(RRCrtcDestroyResource); if (!RRCrtcType) - return FALSE; - RegisterResourceName (RRCrtcType, "CRTC"); + return FALSE; + RegisterResourceName(RRCrtcType, "CRTC"); return TRUE; } int -ProcRRGetCrtcInfo (ClientPtr client) +ProcRRGetCrtcInfo(ClientPtr client) { REQUEST(xRRGetCrtcInfoReq); - xRRGetCrtcInfoReply rep; - RRCrtcPtr crtc; - CARD8 *extra; - unsigned long extraLen; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - RRModePtr mode; - RROutput *outputs; - RROutput *possible; - int i, j, k, n; - int width, height; + xRRGetCrtcInfoReply rep; + RRCrtcPtr crtc; + CARD8 *extra; + unsigned long extraLen; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + RRModePtr mode; + RROutput *outputs; + RROutput *possible; + int i, j, k, n; + int width, height; REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq); crtc = LookupCrtc(client, stuff->crtc, DixReadAccess); if (!crtc) - return RRErrorBase + BadRRCrtc; + return RRErrorBase + BadRRCrtc; /* All crtcs must be associated with screens before client * requests are processed @@ -560,7 +528,7 @@ ProcRRGetCrtcInfo (ClientPtr client) rep.timestamp = pScrPriv->lastSetTime.milliseconds; rep.x = crtc->x; rep.y = crtc->y; - RRCrtcGetScanoutSize (crtc, &width, &height); + RRCrtcGetScanoutSize(crtc, &width, &height); rep.width = width; rep.height = height; rep.mode = mode ? mode->mode.id : 0; @@ -569,175 +537,158 @@ ProcRRGetCrtcInfo (ClientPtr client) rep.nOutput = crtc->numOutputs; k = 0; for (i = 0; i < pScrPriv->numOutputs; i++) - for (j = 0; j < pScrPriv->outputs[i]->numCrtcs; j++) - if (pScrPriv->outputs[i]->crtcs[j] == crtc) - k++; + for (j = 0; j < pScrPriv->outputs[i]->numCrtcs; j++) + if (pScrPriv->outputs[i]->crtcs[j] == crtc) + k++; rep.nPossibleOutput = k; rep.length = rep.nOutput + rep.nPossibleOutput; extraLen = rep.length << 2; - if (extraLen) - { - extra = xalloc (extraLen); - if (!extra) - return BadAlloc; + if (extraLen) { + extra = xalloc(extraLen); + if (!extra) + return BadAlloc; } else - extra = NULL; + extra = NULL; outputs = (RROutput *) extra; possible = (RROutput *) (outputs + rep.nOutput); - for (i = 0; i < crtc->numOutputs; i++) - { - outputs[i] = crtc->outputs[i]->id; - if (client->swapped) - swapl (&outputs[i], n); + for (i = 0; i < crtc->numOutputs; i++) { + outputs[i] = crtc->outputs[i]->id; + if (client->swapped) + swapl(&outputs[i], n); } k = 0; for (i = 0; i < pScrPriv->numOutputs; i++) - for (j = 0; j < pScrPriv->outputs[i]->numCrtcs; j++) - if (pScrPriv->outputs[i]->crtcs[j] == crtc) - { - possible[k] = pScrPriv->outputs[i]->id; - if (client->swapped) - swapl (&possible[k], n); - k++; - } + for (j = 0; j < pScrPriv->outputs[i]->numCrtcs; j++) + if (pScrPriv->outputs[i]->crtcs[j] == crtc) { + possible[k] = pScrPriv->outputs[i]->id; + if (client->swapped) + swapl(&possible[k], n); + k++; + } if (client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.timestamp, n); - swaps(&rep.x, n); - swaps(&rep.y, n); - swaps(&rep.width, n); - swaps(&rep.height, n); - swapl(&rep.mode, n); - swaps(&rep.rotation, n); - swaps(&rep.rotations, n); - swaps(&rep.nOutput, n); - swaps(&rep.nPossibleOutput, n); - } - WriteToClient(client, sizeof(xRRGetCrtcInfoReply), (char *)&rep); - if (extraLen) - { - WriteToClient (client, extraLen, (char *) extra); - xfree (extra); + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.timestamp, n); + swaps(&rep.x, n); + swaps(&rep.y, n); + swaps(&rep.width, n); + swaps(&rep.height, n); + swapl(&rep.mode, n); + swaps(&rep.rotation, n); + swaps(&rep.rotations, n); + swaps(&rep.nOutput, n); + swaps(&rep.nPossibleOutput, n); + } + WriteToClient(client, sizeof(xRRGetCrtcInfoReply), (char *) &rep); + if (extraLen) { + WriteToClient(client, extraLen, (char *) extra); + xfree(extra); } return client->noClientException; } int -ProcRRSetCrtcConfig (ClientPtr client) +ProcRRSetCrtcConfig(ClientPtr client) { REQUEST(xRRSetCrtcConfigReq); - xRRSetCrtcConfigReply rep; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - RRCrtcPtr crtc; - RRModePtr mode; - int numOutputs; - RROutputPtr *outputs = NULL; - RROutput *outputIds; - TimeStamp time; - Rotation rotation; - int i, j; + xRRSetCrtcConfigReply rep; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + RRCrtcPtr crtc; + RRModePtr mode; + int numOutputs; + RROutputPtr *outputs = NULL; + RROutput *outputIds; + TimeStamp time; + Rotation rotation; + int i, j; REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq); - numOutputs = (stuff->length - (SIZEOF (xRRSetCrtcConfigReq) >> 2)); - - crtc = LookupIDByType (stuff->crtc, RRCrtcType); - if (!crtc) - { - client->errorValue = stuff->crtc; - return RRErrorBase + BadRRCrtc; - } - if (stuff->mode == None) - { - mode = NULL; - if (numOutputs > 0) - return BadMatch; - } - else - { - mode = LookupIDByType (stuff->mode, RRModeType); - if (!mode) - { - client->errorValue = stuff->mode; - return RRErrorBase + BadRRMode; - } - if (numOutputs == 0) - return BadMatch; - } - if (numOutputs) - { - outputs = xalloc (numOutputs * sizeof (RROutputPtr)); - if (!outputs) - return BadAlloc; + numOutputs = (stuff->length - (SIZEOF(xRRSetCrtcConfigReq) >> 2)); + + crtc = LookupIDByType(stuff->crtc, RRCrtcType); + if (!crtc) { + client->errorValue = stuff->crtc; + return RRErrorBase + BadRRCrtc; + } + if (stuff->mode == None) { + mode = NULL; + if (numOutputs > 0) + return BadMatch; + } + else { + mode = LookupIDByType(stuff->mode, RRModeType); + if (!mode) { + client->errorValue = stuff->mode; + return RRErrorBase + BadRRMode; + } + if (numOutputs == 0) + return BadMatch; + } + if (numOutputs) { + outputs = xalloc(numOutputs * sizeof(RROutputPtr)); + if (!outputs) + return BadAlloc; } else - outputs = NULL; + outputs = NULL; outputIds = (RROutput *) (stuff + 1); - for (i = 0; i < numOutputs; i++) - { - outputs[i] = (RROutputPtr) LookupIDByType (outputIds[i], RROutputType); - if (!outputs[i]) - { - client->errorValue = outputIds[i]; - if (outputs) - xfree (outputs); - return RRErrorBase + BadRROutput; - } - /* validate crtc for this output */ - for (j = 0; j < outputs[i]->numCrtcs; j++) - if (outputs[i]->crtcs[j] == crtc) - break; - if (j == outputs[i]->numCrtcs) - { - if (outputs) - xfree (outputs); - return BadMatch; - } - /* validate mode for this output */ - for (j = 0; j < outputs[i]->numModes + outputs[i]->numUserModes; j++) - { - RRModePtr m = (j < outputs[i]->numModes ? - outputs[i]->modes[j] : - outputs[i]->userModes[j - outputs[i]->numModes]); - if (m == mode) - break; - } - if (j == outputs[i]->numModes + outputs[i]->numUserModes) - { - if (outputs) - xfree (outputs); - return BadMatch; - } + for (i = 0; i < numOutputs; i++) { + outputs[i] = (RROutputPtr) LookupIDByType(outputIds[i], RROutputType); + if (!outputs[i]) { + client->errorValue = outputIds[i]; + if (outputs) + xfree(outputs); + return RRErrorBase + BadRROutput; + } + /* validate crtc for this output */ + for (j = 0; j < outputs[i]->numCrtcs; j++) + if (outputs[i]->crtcs[j] == crtc) + break; + if (j == outputs[i]->numCrtcs) { + if (outputs) + xfree(outputs); + return BadMatch; + } + /* validate mode for this output */ + for (j = 0; j < outputs[i]->numModes + outputs[i]->numUserModes; j++) { + RRModePtr m = (j < outputs[i]->numModes ? + outputs[i]->modes[j] : + outputs[i]->userModes[j - outputs[i]->numModes]); + if (m == mode) + break; + } + if (j == outputs[i]->numModes + outputs[i]->numUserModes) { + if (outputs) + xfree(outputs); + return BadMatch; + } } /* validate clones */ - for (i = 0; i < numOutputs; i++) - { - for (j = 0; j < numOutputs; j++) - { - int k; - if (i == j) - continue; - for (k = 0; k < outputs[i]->numClones; k++) - { - if (outputs[i]->clones[k] == outputs[j]) - break; - } - if (k == outputs[i]->numClones) - { - if (outputs) - xfree (outputs); - return BadMatch; - } - } + for (i = 0; i < numOutputs; i++) { + for (j = 0; j < numOutputs; j++) { + int k; + + if (i == j) + continue; + for (k = 0; k < outputs[i]->numClones; k++) { + if (outputs[i]->clones[k] == outputs[j]) + break; + } + if (k == outputs[i]->numClones) { + if (outputs) + xfree(outputs); + return BadMatch; + } + } } pScreen = crtc->pScreen; @@ -745,11 +696,10 @@ ProcRRSetCrtcConfig (ClientPtr client) time = ClientTimeToServerTime(stuff->timestamp); - if (!pScrPriv) - { - time = currentTime; - rep.status = RRSetConfigFailed; - goto sendReply; + if (!pScrPriv) { + time = currentTime; + rep.status = RRSetConfigFailed; + goto sendReply; } /* @@ -763,62 +713,57 @@ ProcRRSetCrtcConfig (ClientPtr client) case RR_Rotate_90: case RR_Rotate_180: case RR_Rotate_270: - break; + break; default: - /* - * Invalid rotation - */ - client->errorValue = stuff->rotation; - if (outputs) - xfree (outputs); - return BadValue; - } - - if (mode) - { - if ((~crtc->rotations) & rotation) - { - /* - * requested rotation or reflection not supported by screen - */ - client->errorValue = stuff->rotation; - if (outputs) - xfree (outputs); - return BadMatch; - } + /* + * Invalid rotation + */ + client->errorValue = stuff->rotation; + if (outputs) + xfree(outputs); + return BadValue; + } + + if (mode) { + if ((~crtc->rotations) & rotation) { + /* + * requested rotation or reflection not supported by screen + */ + client->errorValue = stuff->rotation; + if (outputs) + xfree(outputs); + return BadMatch; + } #ifdef RANDR_12_INTERFACE - /* - * Check screen size bounds if the DDX provides a 1.2 interface - * for setting screen size. Else, assume the CrtcSet sets - * the size along with the mode - */ - if (pScrPriv->rrScreenSetSize) - { - int source_width = mode->mode.width; - int source_height = mode->mode.height; - - if ((rotation & 0xf) == RR_Rotate_90 || (rotation & 0xf) == RR_Rotate_270) - { - source_width = mode->mode.height; - source_height = mode->mode.width; - } - if (stuff->x + source_width > pScreen->width) - { - client->errorValue = stuff->x; - if (outputs) - xfree (outputs); - return BadValue; - } - - if (stuff->y + source_height > pScreen->height) - { - client->errorValue = stuff->y; - if (outputs) - xfree (outputs); - return BadValue; - } - } + /* + * Check screen size bounds if the DDX provides a 1.2 interface + * for setting screen size. Else, assume the CrtcSet sets + * the size along with the mode + */ + if (pScrPriv->rrScreenSetSize) { + int source_width = mode->mode.width; + int source_height = mode->mode.height; + + if ((rotation & 0xf) == RR_Rotate_90 || + (rotation & 0xf) == RR_Rotate_270) { + source_width = mode->mode.height; + source_height = mode->mode.width; + } + if (stuff->x + source_width > pScreen->width) { + client->errorValue = stuff->x; + if (outputs) + xfree(outputs); + return BadValue; + } + + if (stuff->y + source_height > pScreen->height) { + client->errorValue = stuff->y; + if (outputs) + xfree(outputs); + return BadValue; + } + } #endif } @@ -826,24 +771,22 @@ ProcRRSetCrtcConfig (ClientPtr client) * Make sure the requested set-time is not older than * the last set-time */ - if (CompareTimeStamps (time, pScrPriv->lastSetTime) < 0) - { - rep.status = RRSetConfigInvalidTime; - goto sendReply; + if (CompareTimeStamps(time, pScrPriv->lastSetTime) < 0) { + rep.status = RRSetConfigInvalidTime; + goto sendReply; } - if (!RRCrtcSet (crtc, mode, stuff->x, stuff->y, - rotation, numOutputs, outputs)) - { - rep.status = RRSetConfigFailed; - goto sendReply; + if (!RRCrtcSet(crtc, mode, stuff->x, stuff->y, + rotation, numOutputs, outputs)) { + rep.status = RRSetConfigFailed; + goto sendReply; } rep.status = RRSetConfigSuccess; pScrPriv->lastSetTime = time; -sendReply: + sendReply: if (outputs) - xfree (outputs); + xfree(outputs); rep.type = X_Reply; /* rep.status has already been filled in */ @@ -851,65 +794,65 @@ sendReply: rep.sequenceNumber = client->sequence; rep.newTimestamp = pScrPriv->lastSetTime.milliseconds; - if (client->swapped) - { - int n; - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.newTimestamp, n); + if (client->swapped) { + int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.newTimestamp, n); } - WriteToClient(client, sizeof(xRRSetCrtcConfigReply), (char *)&rep); + WriteToClient(client, sizeof(xRRSetCrtcConfigReply), (char *) &rep); return client->noClientException; } int -ProcRRGetCrtcGammaSize (ClientPtr client) +ProcRRGetCrtcGammaSize(ClientPtr client) { REQUEST(xRRGetCrtcGammaSizeReq); - xRRGetCrtcGammaSizeReply reply; - RRCrtcPtr crtc; - int n; + xRRGetCrtcGammaSizeReply reply; + RRCrtcPtr crtc; + int n; REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq); - crtc = LookupCrtc (client, stuff->crtc, DixReadAccess); + crtc = LookupCrtc(client, stuff->crtc, DixReadAccess); if (!crtc) - return RRErrorBase + BadRRCrtc; + return RRErrorBase + BadRRCrtc; reply.type = X_Reply; reply.sequenceNumber = client->sequence; reply.length = 0; reply.size = crtc->gammaSize; if (client->swapped) { - swaps (&reply.sequenceNumber, n); - swapl (&reply.length, n); - swaps (&reply.size, n); + swaps(&reply.sequenceNumber, n); + swapl(&reply.length, n); + swaps(&reply.size, n); } - WriteToClient (client, sizeof (xRRGetCrtcGammaSizeReply), (char *) &reply); + WriteToClient(client, sizeof(xRRGetCrtcGammaSizeReply), (char *) &reply); return client->noClientException; } int -ProcRRGetCrtcGamma (ClientPtr client) +ProcRRGetCrtcGamma(ClientPtr client) { REQUEST(xRRGetCrtcGammaReq); - xRRGetCrtcGammaReply reply; - RRCrtcPtr crtc; - int n; - unsigned long len; - char *extra; + xRRGetCrtcGammaReply reply; + RRCrtcPtr crtc; + int n; + unsigned long len; + char *extra; REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq); - crtc = LookupCrtc (client, stuff->crtc, DixReadAccess); + crtc = LookupCrtc(client, stuff->crtc, DixReadAccess); if (!crtc) - return RRErrorBase + BadRRCrtc; + return RRErrorBase + BadRRCrtc; len = crtc->gammaSize * 3 * 2; if (crtc->gammaSize) { - extra = xalloc(len); - if (!extra) - return BadAlloc; + extra = xalloc(len); + if (!extra) + return BadAlloc; } reply.type = X_Reply; @@ -917,47 +860,45 @@ ProcRRGetCrtcGamma (ClientPtr client) reply.length = (len + 3) >> 2; reply.size = crtc->gammaSize; if (client->swapped) { - swaps (&reply.sequenceNumber, n); - swapl (&reply.length, n); - swaps (&reply.size, n); - } - WriteToClient (client, sizeof (xRRGetCrtcGammaReply), (char *) &reply); - if (crtc->gammaSize) - { - memcpy(extra, crtc->gammaRed, len); - client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; - WriteSwappedDataToClient (client, len, extra); - xfree(extra); + swaps(&reply.sequenceNumber, n); + swapl(&reply.length, n); + swaps(&reply.size, n); + } + WriteToClient(client, sizeof(xRRGetCrtcGammaReply), (char *) &reply); + if (crtc->gammaSize) { + memcpy(extra, crtc->gammaRed, len); + client->pSwapReplyFunc = (ReplySwapPtr) CopySwap16Write; + WriteSwappedDataToClient(client, len, extra); + xfree(extra); } return client->noClientException; } int -ProcRRSetCrtcGamma (ClientPtr client) +ProcRRSetCrtcGamma(ClientPtr client) { REQUEST(xRRSetCrtcGammaReq); - RRCrtcPtr crtc; - unsigned long len; - CARD16 *red, *green, *blue; + RRCrtcPtr crtc; + unsigned long len; + CARD16 *red, *green, *blue; REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq); - crtc = LookupCrtc (client, stuff->crtc, DixWriteAccess); + crtc = LookupCrtc(client, stuff->crtc, DixWriteAccess); if (!crtc) - return RRErrorBase + BadRRCrtc; + return RRErrorBase + BadRRCrtc; - len = client->req_len - (sizeof (xRRSetCrtcGammaReq) >> 2); + len = client->req_len - (sizeof(xRRSetCrtcGammaReq) >> 2); if (len < (stuff->size * 3 + 1) >> 1) - return BadLength; + return BadLength; if (stuff->size != crtc->gammaSize) - return BadMatch; + return BadMatch; red = (CARD16 *) (stuff + 1); green = red + crtc->gammaSize; blue = green + crtc->gammaSize; - RRCrtcGammaSet (crtc, red, green, blue); + RRCrtcGammaSet(crtc, red, green, blue); return Success; } - diff --git a/nx-X11/programs/Xserver/randr/rrdispatch.c b/nx-X11/programs/Xserver/randr/rrdispatch.c index 88970937e..a8fa6965f 100644 --- a/nx-X11/programs/Xserver/randr/rrdispatch.c +++ b/nx-X11/programs/Xserver/randr/rrdispatch.c @@ -26,19 +26,20 @@ #define SERVER_RANDR_MINOR 2 Bool -RRClientKnowsRates (ClientPtr pClient) +RRClientKnowsRates(ClientPtr pClient) { rrClientPriv(pClient); return (pRRClient->major_version > 1 || - (pRRClient->major_version == 1 && pRRClient->minor_version >= 1)); + (pRRClient->major_version == 1 && pRRClient->minor_version >= 1)); } static int -ProcRRQueryVersion (ClientPtr client) +ProcRRQueryVersion(ClientPtr client) { xRRQueryVersionReply rep; register int n; + REQUEST(xRRQueryVersionReq); rrClientPriv(client); @@ -55,165 +56,157 @@ ProcRRQueryVersion (ClientPtr client) rep.majorVersion = SERVER_RANDR_MAJOR; rep.minorVersion = SERVER_RANDR_MINOR; if (client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.majorVersion, n); - swapl(&rep.minorVersion, n); + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.majorVersion, n); + swapl(&rep.minorVersion, n); } - WriteToClient(client, sizeof(xRRQueryVersionReply), (char *)&rep); + WriteToClient(client, sizeof(xRRQueryVersionReply), (char *) &rep); return (client->noClientException); } static int -ProcRRSelectInput (ClientPtr client) +ProcRRSelectInput(ClientPtr client) { REQUEST(xRRSelectInputReq); rrClientPriv(client); - RRTimesPtr pTimes; - WindowPtr pWin; - RREventPtr pRREvent, *pHead; - XID clientResource; - int rc; + RRTimesPtr pTimes; + WindowPtr pWin; + RREventPtr pRREvent, *pHead; + XID clientResource; + int rc; REQUEST_SIZE_MATCH(xRRSelectInputReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixWriteAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityWriteAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; - pHead = (RREventPtr *)SecurityLookupIDByType(client, - pWin->drawable.id, RREventType, - DixWriteAccess); + return rc; + pHead = (RREventPtr *) SecurityLookupIDByType(client, + pWin->drawable.id, + RREventType, DixWriteAccess); + + if (stuff->enable & (RRScreenChangeNotifyMask | + RRCrtcChangeNotifyMask | RROutputChangeNotifyMask)) { + ScreenPtr pScreen = pWin->drawable.pScreen; - if (stuff->enable & (RRScreenChangeNotifyMask| - RRCrtcChangeNotifyMask| - RROutputChangeNotifyMask)) - { - ScreenPtr pScreen = pWin->drawable.pScreen; - rrScrPriv (pScreen); + rrScrPriv(pScreen); - pRREvent = NULL; - if (pHead) - { - /* check for existing entry. */ - for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) - if (pRREvent->client == client) - break; - } + pRREvent = NULL; + if (pHead) { + /* check for existing entry. */ + for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) + if (pRREvent->client == client) + break; + } - if (!pRREvent) - { - /* build the entry */ - pRREvent = (RREventPtr) xalloc (sizeof (RREventRec)); - if (!pRREvent) - return BadAlloc; - pRREvent->next = 0; - pRREvent->client = client; - pRREvent->window = pWin; - pRREvent->mask = stuff->enable; - /* - * add a resource that will be deleted when - * the client goes away - */ - clientResource = FakeClientID (client->index); - pRREvent->clientResource = clientResource; - if (!AddResource (clientResource, RRClientType, (void *)pRREvent)) - return BadAlloc; - /* - * create a resource to contain a pointer to the list - * of clients selecting input. This must be indirect as - * the list may be arbitrarily rearranged which cannot be - * done through the resource database. - */ - if (!pHead) - { - pHead = (RREventPtr *) xalloc (sizeof (RREventPtr)); - if (!pHead || - !AddResource (pWin->drawable.id, RREventType, (void *)pHead)) - { - FreeResource (clientResource, RT_NONE); - return BadAlloc; - } - *pHead = 0; - } - pRREvent->next = *pHead; - *pHead = pRREvent; - } - /* - * Now see if the client needs an event - */ - if (pScrPriv && (pRREvent->mask & RRScreenChangeNotifyMask)) - { - pTimes = &((RRTimesPtr) (pRRClient + 1))[pScreen->myNum]; - if (CompareTimeStamps (pTimes->setTime, - pScrPriv->lastSetTime) != 0 || - CompareTimeStamps (pTimes->configTime, - pScrPriv->lastConfigTime) != 0) - { - RRDeliverScreenEvent (client, pWin, pScreen); - } - } + if (!pRREvent) { + /* build the entry */ + pRREvent = (RREventPtr) xalloc(sizeof(RREventRec)); + if (!pRREvent) + return BadAlloc; + pRREvent->next = 0; + pRREvent->client = client; + pRREvent->window = pWin; + pRREvent->mask = stuff->enable; + /* + * add a resource that will be deleted when + * the client goes away + */ + clientResource = FakeClientID(client->index); + pRREvent->clientResource = clientResource; + if (!AddResource(clientResource, RRClientType, (void *) pRREvent)) + return BadAlloc; + /* + * create a resource to contain a pointer to the list + * of clients selecting input. This must be indirect as + * the list may be arbitrarily rearranged which cannot be + * done through the resource database. + */ + if (!pHead) { + pHead = (RREventPtr *) xalloc(sizeof(RREventPtr)); + if (!pHead || + !AddResource(pWin->drawable.id, RREventType, + (void *) pHead)) { + FreeResource(clientResource, RT_NONE); + return BadAlloc; + } + *pHead = 0; + } + pRREvent->next = *pHead; + *pHead = pRREvent; + } + /* + * Now see if the client needs an event + */ + if (pScrPriv && (pRREvent->mask & RRScreenChangeNotifyMask)) { + pTimes = &((RRTimesPtr) (pRRClient + 1))[pScreen->myNum]; + if (CompareTimeStamps(pTimes->setTime, + pScrPriv->lastSetTime) != 0 || + CompareTimeStamps(pTimes->configTime, + pScrPriv->lastConfigTime) != 0) { + RRDeliverScreenEvent(client, pWin, pScreen); + } + } } - else if (stuff->enable == 0) - { - /* delete the interest */ - if (pHead) { - RREventPtr pNewRREvent = 0; - for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) { - if (pRREvent->client == client) - break; - pNewRREvent = pRREvent; - } - if (pRREvent) { - FreeResource (pRREvent->clientResource, RRClientType); - if (pNewRREvent) - pNewRREvent->next = pRREvent->next; - else - *pHead = pRREvent->next; - xfree (pRREvent); - } - } + else if (stuff->enable == 0) { + /* delete the interest */ + if (pHead) { + RREventPtr pNewRREvent = 0; + + for (pRREvent = *pHead; pRREvent; pRREvent = pRREvent->next) { + if (pRREvent->client == client) + break; + pNewRREvent = pRREvent; + } + if (pRREvent) { + FreeResource(pRREvent->clientResource, RRClientType); + if (pNewRREvent) + pNewRREvent->next = pRREvent->next; + else + *pHead = pRREvent->next; + xfree(pRREvent); + } + } } - else - { - client->errorValue = stuff->enable; - return BadValue; + else { + client->errorValue = stuff->enable; + return BadValue; } return Success; } -int (*ProcRandrVector[RRNumberRequests])(ClientPtr) = { - ProcRRQueryVersion, /* 0 */ +int (*ProcRandrVector[RRNumberRequests]) (ClientPtr) = { + ProcRRQueryVersion, /* 0 */ /* we skip 1 to make old clients fail pretty immediately */ - NULL, /* 1 ProcRandrOldGetScreenInfo */ + NULL, /* 1 ProcRandrOldGetScreenInfo */ /* V1.0 apps share the same set screen config request id */ - ProcRRSetScreenConfig, /* 2 */ - NULL, /* 3 ProcRandrOldScreenChangeSelectInput */ + ProcRRSetScreenConfig, /* 2 */ + NULL, /* 3 ProcRandrOldScreenChangeSelectInput */ /* 3 used to be ScreenChangeSelectInput; deprecated */ - ProcRRSelectInput, /* 4 */ - ProcRRGetScreenInfo, /* 5 */ + ProcRRSelectInput, /* 4 */ + ProcRRGetScreenInfo, /* 5 */ /* V1.2 additions */ - ProcRRGetScreenSizeRange, /* 6 */ - ProcRRSetScreenSize, /* 7 */ - ProcRRGetScreenResources, /* 8 */ - ProcRRGetOutputInfo, /* 9 */ - ProcRRListOutputProperties, /* 10 */ - ProcRRQueryOutputProperty, /* 11 */ - ProcRRConfigureOutputProperty, /* 12 */ - ProcRRChangeOutputProperty, /* 13 */ - ProcRRDeleteOutputProperty, /* 14 */ - ProcRRGetOutputProperty, /* 15 */ - ProcRRCreateMode, /* 16 */ - ProcRRDestroyMode, /* 17 */ - ProcRRAddOutputMode, /* 18 */ - ProcRRDeleteOutputMode, /* 19 */ - ProcRRGetCrtcInfo, /* 20 */ - ProcRRSetCrtcConfig, /* 21 */ - ProcRRGetCrtcGammaSize, /* 22 */ - ProcRRGetCrtcGamma, /* 23 */ - ProcRRSetCrtcGamma, /* 24 */ + ProcRRGetScreenSizeRange, /* 6 */ + ProcRRSetScreenSize, /* 7 */ + ProcRRGetScreenResources, /* 8 */ + ProcRRGetOutputInfo, /* 9 */ + ProcRRListOutputProperties, /* 10 */ + ProcRRQueryOutputProperty, /* 11 */ + ProcRRConfigureOutputProperty, /* 12 */ + ProcRRChangeOutputProperty, /* 13 */ + ProcRRDeleteOutputProperty, /* 14 */ + ProcRRGetOutputProperty, /* 15 */ + ProcRRCreateMode, /* 16 */ + ProcRRDestroyMode, /* 17 */ + ProcRRAddOutputMode, /* 18 */ + ProcRRDeleteOutputMode, /* 19 */ + ProcRRGetCrtcInfo, /* 20 */ + ProcRRSetCrtcConfig, /* 21 */ + ProcRRGetCrtcGammaSize, /* 22 */ + ProcRRGetCrtcGamma, /* 23 */ + ProcRRSetCrtcGamma, /* 24 */ }; - diff --git a/nx-X11/programs/Xserver/randr/rrinfo.c b/nx-X11/programs/Xserver/randr/rrinfo.c index 1f14c81f8..070f5ca0c 100644 --- a/nx-X11/programs/Xserver/randr/rrinfo.c +++ b/nx-X11/programs/Xserver/randr/rrinfo.c @@ -24,46 +24,45 @@ #ifdef RANDR_10_INTERFACE static RRModePtr -RROldModeAdd (RROutputPtr output, RRScreenSizePtr size, int refresh) +RROldModeAdd(RROutputPtr output, RRScreenSizePtr size, int refresh) { - ScreenPtr pScreen = output->pScreen; + ScreenPtr pScreen = output->pScreen; + rrScrPriv(pScreen); - xRRModeInfo modeInfo; - char name[100]; - RRModePtr mode; - int i; - RRModePtr *modes; + xRRModeInfo modeInfo; + char name[100]; + RRModePtr mode; + int i; + RRModePtr *modes; - memset (&modeInfo, '\0', sizeof (modeInfo)); - sprintf (name, "%dx%d", size->width, size->height); + memset(&modeInfo, '\0', sizeof(modeInfo)); + sprintf(name, "%dx%d", size->width, size->height); modeInfo.width = size->width; modeInfo.height = size->height; modeInfo.hTotal = size->width; modeInfo.vTotal = size->height; modeInfo.dotClock = ((CARD32) size->width * (CARD32) size->height * - (CARD32) refresh); - modeInfo.nameLength = strlen (name); - mode = RRModeGet (&modeInfo, name); + (CARD32) refresh); + modeInfo.nameLength = strlen(name); + mode = RRModeGet(&modeInfo, name); if (!mode) - return NULL; + return NULL; for (i = 0; i < output->numModes; i++) - if (output->modes[i] == mode) - { - RRModeDestroy (mode); - return mode; - } + if (output->modes[i] == mode) { + RRModeDestroy(mode); + return mode; + } if (output->numModes) - modes = xrealloc (output->modes, - (output->numModes + 1) * sizeof (RRModePtr)); + modes = xrealloc(output->modes, + (output->numModes + 1) * sizeof(RRModePtr)); else - modes = xalloc (sizeof (RRModePtr)); - if (!modes) - { - RRModeDestroy (mode); - FreeResource (mode->mode.id, 0); - return NULL; + modes = xalloc(sizeof(RRModePtr)); + if (!modes) { + RRModeDestroy(mode); + FreeResource(mode->mode.id, 0); + return NULL; } modes[output->numModes++] = mode; output->modes = modes; @@ -74,104 +73,97 @@ RROldModeAdd (RROutputPtr output, RRScreenSizePtr size, int refresh) } static void -RRScanOldConfig (ScreenPtr pScreen, Rotation rotations) +RRScanOldConfig(ScreenPtr pScreen, Rotation rotations) { rrScrPriv(pScreen); - RROutputPtr output; - RRCrtcPtr crtc; - RRModePtr mode, newMode = NULL; - int i; - CARD16 minWidth = MAXSHORT, minHeight = MAXSHORT; - CARD16 maxWidth = 0, maxHeight = 0; - CARD16 width, height; + RROutputPtr output; + RRCrtcPtr crtc; + RRModePtr mode, newMode = NULL; + int i; + CARD16 minWidth = MAXSHORT, minHeight = MAXSHORT; + CARD16 maxWidth = 0, maxHeight = 0; + CARD16 width, height; /* * First time through, create a crtc and output and hook * them together */ - if (pScrPriv->numOutputs == 0 && - pScrPriv->numCrtcs == 0) - { - crtc = RRCrtcCreate (pScreen, NULL); - if (!crtc) - return; - output = RROutputCreate (pScreen, "default", 7, NULL); - if (!output) - return; - RROutputSetCrtcs (output, &crtc, 1); - RROutputSetConnection (output, RR_Connected); + if (pScrPriv->numOutputs == 0 && pScrPriv->numCrtcs == 0) { + crtc = RRCrtcCreate(pScreen, NULL); + if (!crtc) + return; + output = RROutputCreate(pScreen, "default", 7, NULL); + if (!output) + return; + RROutputSetCrtcs(output, &crtc, 1); + RROutputSetConnection(output, RR_Connected); #ifdef RENDER - RROutputSetSubpixelOrder (output, PictureGetSubpixelOrder (pScreen)); + RROutputSetSubpixelOrder(output, PictureGetSubpixelOrder(pScreen)); #endif } output = pScrPriv->outputs[0]; if (!output) - return; + return; crtc = pScrPriv->crtcs[0]; if (!crtc) - return; + return; /* check rotations */ - if (rotations != crtc->rotations) - { + if (rotations != crtc->rotations) { crtc->rotations = rotations; - crtc->changed = TRUE; - pScrPriv->changed = TRUE; + crtc->changed = TRUE; + pScrPriv->changed = TRUE; } - + /* regenerate mode list */ - for (i = 0; i < pScrPriv->nSizes; i++) - { - RRScreenSizePtr size = &pScrPriv->pSizes[i]; - int r; - - if (size->nRates) - { - for (r = 0; r < size->nRates; r++) - { - mode = RROldModeAdd (output, size, size->pRates[r].rate); - if (i == pScrPriv->size && - size->pRates[r].rate == pScrPriv->rate) - { - newMode = mode; - } - } - xfree (size->pRates); - } - else - { - mode = RROldModeAdd (output, size, 0); - if (i == pScrPriv->size) - newMode = mode; - } + for (i = 0; i < pScrPriv->nSizes; i++) { + RRScreenSizePtr size = &pScrPriv->pSizes[i]; + int r; + + if (size->nRates) { + for (r = 0; r < size->nRates; r++) { + mode = RROldModeAdd(output, size, size->pRates[r].rate); + if (i == pScrPriv->size && + size->pRates[r].rate == pScrPriv->rate) { + newMode = mode; + } + } + xfree(size->pRates); + } + else { + mode = RROldModeAdd(output, size, 0); + if (i == pScrPriv->size) + newMode = mode; + } } if (pScrPriv->nSizes) - xfree (pScrPriv->pSizes); + xfree(pScrPriv->pSizes); pScrPriv->pSizes = NULL; pScrPriv->nSizes = 0; - + /* find size bounds */ - for (i = 0; i < output->numModes + output->numUserModes; i++) - { - mode = (i < output->numModes ? - output->modes[i] : - output->userModes[i-output->numModes]); + for (i = 0; i < output->numModes + output->numUserModes; i++) { + mode = (i < output->numModes ? + output->modes[i] : output->userModes[i - output->numModes]); width = mode->mode.width; height = mode->mode.height; - - if (width < minWidth) minWidth = width; - if (width > maxWidth) maxWidth = width; - if (height < minHeight) minHeight = height; - if (height > maxHeight) maxHeight = height; + + if (width < minWidth) + minWidth = width; + if (width > maxWidth) + maxWidth = width; + if (height < minHeight) + minHeight = height; + if (height > maxHeight) + maxHeight = height; } - RRScreenSetSizeRange (pScreen, minWidth, minHeight, maxWidth, maxHeight); + RRScreenSetSizeRange(pScreen, minWidth, minHeight, maxWidth, maxHeight); /* notice current mode */ if (newMode) - RRCrtcNotify (crtc, newMode, 0, 0, pScrPriv->rotation, - 1, &output); + RRCrtcNotify(crtc, newMode, 0, 0, pScrPriv->rotation, 1, &output); } #endif @@ -179,29 +171,29 @@ RRScanOldConfig (ScreenPtr pScreen, Rotation rotations) * Poll the driver for changed information */ Bool -RRGetInfo (ScreenPtr pScreen) +RRGetInfo(ScreenPtr pScreen) { - rrScrPriv (pScreen); - Rotation rotations; - int i; + rrScrPriv(pScreen); + Rotation rotations; + int i; for (i = 0; i < pScrPriv->numOutputs; i++) - pScrPriv->outputs[i]->changed = FALSE; + pScrPriv->outputs[i]->changed = FALSE; for (i = 0; i < pScrPriv->numCrtcs; i++) - pScrPriv->crtcs[i]->changed = FALSE; + pScrPriv->crtcs[i]->changed = FALSE; rotations = 0; pScrPriv->changed = FALSE; pScrPriv->configChanged = FALSE; if (!(*pScrPriv->rrGetInfo) (pScreen, &rotations)) - return FALSE; + return FALSE; #if RANDR_10_INTERFACE if (pScrPriv->nSizes) - RRScanOldConfig (pScreen, rotations); + RRScanOldConfig(pScreen, rotations); #endif - RRTellChanged (pScreen); + RRTellChanged(pScreen); return TRUE; } @@ -209,25 +201,22 @@ RRGetInfo (ScreenPtr pScreen) * Register the range of sizes for the screen */ void -RRScreenSetSizeRange (ScreenPtr pScreen, - CARD16 minWidth, - CARD16 minHeight, - CARD16 maxWidth, - CARD16 maxHeight) +RRScreenSetSizeRange(ScreenPtr pScreen, + CARD16 minWidth, + CARD16 minHeight, CARD16 maxWidth, CARD16 maxHeight) { - rrScrPriv (pScreen); + rrScrPriv(pScreen); if (!pScrPriv) - return; + return; if (pScrPriv->minWidth == minWidth && pScrPriv->minHeight == minHeight && - pScrPriv->maxWidth == maxWidth && pScrPriv->maxHeight == maxHeight) - { - return; + pScrPriv->maxWidth == maxWidth && pScrPriv->maxHeight == maxHeight) { + return; } - - pScrPriv->minWidth = minWidth; + + pScrPriv->minWidth = minWidth; pScrPriv->minHeight = minHeight; - pScrPriv->maxWidth = maxWidth; + pScrPriv->maxWidth = maxWidth; pScrPriv->maxHeight = maxHeight; pScrPriv->changed = TRUE; pScrPriv->configChanged = TRUE; @@ -235,73 +224,67 @@ RRScreenSetSizeRange (ScreenPtr pScreen, #ifdef RANDR_10_INTERFACE static Bool -RRScreenSizeMatches (RRScreenSizePtr a, - RRScreenSizePtr b) +RRScreenSizeMatches(RRScreenSizePtr a, RRScreenSizePtr b) { if (a->width != b->width) - return FALSE; + return FALSE; if (a->height != b->height) - return FALSE; + return FALSE; if (a->mmWidth != b->mmWidth) - return FALSE; + return FALSE; if (a->mmHeight != b->mmHeight) - return FALSE; + return FALSE; return TRUE; } RRScreenSizePtr -RRRegisterSize (ScreenPtr pScreen, - short width, - short height, - short mmWidth, - short mmHeight) +RRRegisterSize(ScreenPtr pScreen, + short width, short height, short mmWidth, short mmHeight) { - rrScrPriv (pScreen); - int i; - RRScreenSize tmp; + rrScrPriv(pScreen); + int i; + RRScreenSize tmp; RRScreenSizePtr pNew; if (!pScrPriv) - return 0; + return 0; tmp.id = 0; tmp.width = width; - tmp.height= height; + tmp.height = height; tmp.mmWidth = mmWidth; tmp.mmHeight = mmHeight; tmp.pRates = 0; tmp.nRates = 0; for (i = 0; i < pScrPriv->nSizes; i++) - if (RRScreenSizeMatches (&tmp, &pScrPriv->pSizes[i])) - return &pScrPriv->pSizes[i]; - pNew = xrealloc (pScrPriv->pSizes, - (pScrPriv->nSizes + 1) * sizeof (RRScreenSize)); + if (RRScreenSizeMatches(&tmp, &pScrPriv->pSizes[i])) + return &pScrPriv->pSizes[i]; + pNew = xrealloc(pScrPriv->pSizes, + (pScrPriv->nSizes + 1) * sizeof(RRScreenSize)); if (!pNew) - return 0; + return 0; pNew[pScrPriv->nSizes++] = tmp; pScrPriv->pSizes = pNew; - return &pNew[pScrPriv->nSizes-1]; + return &pNew[pScrPriv->nSizes - 1]; } -Bool RRRegisterRate (ScreenPtr pScreen, - RRScreenSizePtr pSize, - int rate) +Bool +RRRegisterRate(ScreenPtr pScreen, RRScreenSizePtr pSize, int rate) { rrScrPriv(pScreen); - int i; + int i; RRScreenRatePtr pNew, pRate; if (!pScrPriv) - return FALSE; + return FALSE; for (i = 0; i < pSize->nRates; i++) - if (pSize->pRates[i].rate == rate) - return TRUE; + if (pSize->pRates[i].rate == rate) + return TRUE; - pNew = xrealloc (pSize->pRates, - (pSize->nRates + 1) * sizeof (RRScreenRate)); + pNew = xrealloc(pSize->pRates, (pSize->nRates + 1) * sizeof(RRScreenRate)); if (!pNew) - return FALSE; + return FALSE; pRate = &pNew[pSize->nRates++]; pRate->rate = rate; pSize->pRates = pNew; @@ -311,24 +294,22 @@ Bool RRRegisterRate (ScreenPtr pScreen, Rotation RRGetRotation(ScreenPtr pScreen) { - RROutputPtr output = RRFirstOutput (pScreen); + RROutputPtr output = RRFirstOutput(pScreen); if (!output) - return RR_Rotate_0; + return RR_Rotate_0; return output->crtc->rotation; } void -RRSetCurrentConfig (ScreenPtr pScreen, - Rotation rotation, - int rate, - RRScreenSizePtr pSize) +RRSetCurrentConfig(ScreenPtr pScreen, + Rotation rotation, int rate, RRScreenSizePtr pSize) { - rrScrPriv (pScreen); + rrScrPriv(pScreen); if (!pScrPriv) - return; + return; pScrPriv->size = pSize - pScrPriv->pSizes; pScrPriv->rotation = rotation; pScrPriv->rate = rate; diff --git a/nx-X11/programs/Xserver/randr/rrmode.c b/nx-X11/programs/Xserver/randr/rrmode.c index 9f64fb424..4fe116400 100644 --- a/nx-X11/programs/Xserver/randr/rrmode.c +++ b/nx-X11/programs/Xserver/randr/rrmode.c @@ -40,61 +40,70 @@ #include "randrstr.h" #include "registry.h" -RESTYPE RRModeType; +RESTYPE RRModeType; static Bool -RRModeEqual (xRRModeInfo *a, xRRModeInfo *b) +RRModeEqual(xRRModeInfo * a, xRRModeInfo * b) { - if (a->width != b->width) return FALSE; - if (a->height != b->height) return FALSE; - if (a->dotClock != b->dotClock) return FALSE; - if (a->hSyncStart != b->hSyncStart) return FALSE; - if (a->hSyncEnd != b->hSyncEnd) return FALSE; - if (a->hTotal != b->hTotal) return FALSE; - if (a->hSkew != b->hSkew) return FALSE; - if (a->vSyncStart != b->vSyncStart) return FALSE; - if (a->vSyncEnd != b->vSyncEnd) return FALSE; - if (a->vTotal != b->vTotal) return FALSE; - if (a->nameLength != b->nameLength) return FALSE; - if (a->modeFlags != b->modeFlags) return FALSE; + if (a->width != b->width) + return FALSE; + if (a->height != b->height) + return FALSE; + if (a->dotClock != b->dotClock) + return FALSE; + if (a->hSyncStart != b->hSyncStart) + return FALSE; + if (a->hSyncEnd != b->hSyncEnd) + return FALSE; + if (a->hTotal != b->hTotal) + return FALSE; + if (a->hSkew != b->hSkew) + return FALSE; + if (a->vSyncStart != b->vSyncStart) + return FALSE; + if (a->vSyncEnd != b->vSyncEnd) + return FALSE; + if (a->vTotal != b->vTotal) + return FALSE; + if (a->nameLength != b->nameLength) + return FALSE; + if (a->modeFlags != b->modeFlags) + return FALSE; return TRUE; } /* * Keep a list so it's easy to find modes in the resource database. */ -static int num_modes; -static RRModePtr *modes; +static int num_modes; +static RRModePtr *modes; static RRModePtr -RRModeCreate (xRRModeInfo *modeInfo, - const char *name, - ScreenPtr userScreen) +RRModeCreate(xRRModeInfo * modeInfo, const char *name, ScreenPtr userScreen) { - RRModePtr mode, *newModes; + RRModePtr mode, *newModes; - if (!RRInit ()) - return NULL; + if (!RRInit()) + return NULL; - mode = xalloc (sizeof (RRModeRec) + modeInfo->nameLength + 1); + mode = xalloc(sizeof(RRModeRec) + modeInfo->nameLength + 1); if (!mode) - return NULL; + return NULL; mode->refcnt = 1; mode->mode = *modeInfo; mode->name = (char *) (mode + 1); - memcpy (mode->name, name, modeInfo->nameLength); + memcpy(mode->name, name, modeInfo->nameLength); mode->name[modeInfo->nameLength] = '\0'; mode->userScreen = userScreen; if (num_modes) - newModes = xrealloc (modes, (num_modes + 1) * sizeof (RRModePtr)); + newModes = xrealloc(modes, (num_modes + 1) * sizeof(RRModePtr)); else - newModes = xalloc (sizeof (RRModePtr)); + newModes = xalloc(sizeof(RRModePtr)); - if (!newModes) - { - xfree (mode); - return NULL; + if (!newModes) { + xfree(mode); + return NULL; } mode->mode.id = FakeClientID(0); @@ -109,151 +118,145 @@ RRModeCreate (xRRModeInfo *modeInfo, */ ++mode->refcnt; #ifdef DEBUG - fprintf(stderr, "RRModeCreate: num_modes [%d] new mode [%s] ([%p]) refcnt [%d]\n", num_modes, mode->name, mode, mode->refcnt); + fprintf(stderr, + "RRModeCreate: num_modes [%d] new mode [%s] ([%p]) refcnt [%d]\n", + num_modes, mode->name, mode, mode->refcnt); #endif return mode; } static RRModePtr -RRModeFindByName (const char *name, - CARD16 nameLength) +RRModeFindByName(const char *name, CARD16 nameLength) { - int i; - RRModePtr mode; - - for (i = 0; i < num_modes; i++) - { - mode = modes[i]; - if (mode->mode.nameLength == nameLength && - !memcmp (name, mode->name, nameLength)) - { - return mode; - } + int i; + RRModePtr mode; + + for (i = 0; i < num_modes; i++) { + mode = modes[i]; + if (mode->mode.nameLength == nameLength && + !memcmp(name, mode->name, nameLength)) { + return mode; + } } return NULL; } RRModePtr -RRModeGet (xRRModeInfo *modeInfo, - const char *name) +RRModeGet(xRRModeInfo * modeInfo, const char *name) { - int i; + int i; - for (i = 0; i < num_modes; i++) - { - RRModePtr mode = modes[i]; - if (RRModeEqual (&mode->mode, modeInfo) && - !memcmp (name, mode->name, modeInfo->nameLength)) - { - ++mode->refcnt; + for (i = 0; i < num_modes; i++) { + RRModePtr mode = modes[i]; + + if (RRModeEqual(&mode->mode, modeInfo) && + !memcmp(name, mode->name, modeInfo->nameLength)) { + ++mode->refcnt; #ifdef DEBUG - fprintf(stderr, "RRModeGet: return existing mode [%s] ([%p]) refcnt [%d]\n", mode->name, mode, mode->refcnt); + fprintf(stderr, + "RRModeGet: return existing mode [%s] ([%p]) refcnt [%d]\n", + mode->name, mode, mode->refcnt); #endif - return mode; - } + return mode; + } } #ifdef DEBUG { - RRModePtr mode = RRModeCreate (modeInfo, name, NULL); - fprintf(stderr, "RRModeGet: return new mode [%s] ([%p]) refcnt [%d]\n", mode->name, mode, mode->refcnt); - return mode; + RRModePtr mode = RRModeCreate(modeInfo, name, NULL); + + fprintf(stderr, "RRModeGet: return new mode [%s] ([%p]) refcnt [%d]\n", + mode->name, mode, mode->refcnt); + return mode; } #else - return RRModeCreate (modeInfo, name, NULL); + return RRModeCreate(modeInfo, name, NULL); #endif } static RRModePtr -RRModeCreateUser (ScreenPtr pScreen, - xRRModeInfo *modeInfo, - const char *name, - int *error) +RRModeCreateUser(ScreenPtr pScreen, + xRRModeInfo * modeInfo, const char *name, int *error) { - RRModePtr mode; + RRModePtr mode; - mode = RRModeFindByName (name, modeInfo->nameLength); - if (mode) - { - *error = BadName; - return NULL; + mode = RRModeFindByName(name, modeInfo->nameLength); + if (mode) { + *error = BadName; + return NULL; } - mode = RRModeCreate (modeInfo, name, pScreen); - if (!mode) - { - *error = BadAlloc; - return NULL; + mode = RRModeCreate(modeInfo, name, pScreen); + if (!mode) { + *error = BadAlloc; + return NULL; } *error = Success; return mode; } RRModePtr * -RRModesForScreen (ScreenPtr pScreen, int *num_ret) +RRModesForScreen(ScreenPtr pScreen, int *num_ret) { rrScrPriv(pScreen); - int o, c, m; - RRModePtr *screen_modes; - int num_screen_modes = 0; + int o, c, m; + RRModePtr *screen_modes; + int num_screen_modes = 0; - screen_modes = xalloc ((num_modes ? num_modes : 1) * sizeof (RRModePtr)); + screen_modes = xalloc((num_modes ? num_modes : 1) * sizeof(RRModePtr)); if (!screen_modes) - return NULL; + return NULL; /* * Add modes from all outputs */ - for (o = 0; o < pScrPriv->numOutputs; o++) - { - RROutputPtr output = pScrPriv->outputs[o]; - int n; - - for (m = 0; m < output->numModes + output->numUserModes; m++) - { - RRModePtr mode = (m < output->numModes ? - output->modes[m] : - output->userModes[m-output->numModes]); - for (n = 0; n < num_screen_modes; n++) - if (screen_modes[n] == mode) - break; - if (n == num_screen_modes) - screen_modes[num_screen_modes++] = mode; - } + for (o = 0; o < pScrPriv->numOutputs; o++) { + RROutputPtr output = pScrPriv->outputs[o]; + int n; + + for (m = 0; m < output->numModes + output->numUserModes; m++) { + RRModePtr mode = (m < output->numModes ? + output->modes[m] : + output->userModes[m - output->numModes]); + for (n = 0; n < num_screen_modes; n++) + if (screen_modes[n] == mode) + break; + if (n == num_screen_modes) + screen_modes[num_screen_modes++] = mode; + } } /* * Add modes from all crtcs. The goal is to * make sure all available and active modes * are visible to the client */ - for (c = 0; c < pScrPriv->numCrtcs; c++) - { - RRCrtcPtr crtc = pScrPriv->crtcs[c]; - RRModePtr mode = crtc->mode; - int n; - - if (!mode) continue; - for (n = 0; n < num_screen_modes; n++) - if (screen_modes[n] == mode) - break; - if (n == num_screen_modes) - screen_modes[num_screen_modes++] = mode; + for (c = 0; c < pScrPriv->numCrtcs; c++) { + RRCrtcPtr crtc = pScrPriv->crtcs[c]; + RRModePtr mode = crtc->mode; + int n; + + if (!mode) + continue; + for (n = 0; n < num_screen_modes; n++) + if (screen_modes[n] == mode) + break; + if (n == num_screen_modes) + screen_modes[num_screen_modes++] = mode; } /* * Add all user modes for this screen */ - for (m = 0; m < num_modes; m++) - { - RRModePtr mode = modes[m]; - int n; - - if (mode->userScreen != pScreen) - continue; - for (n = 0; n < num_screen_modes; n++) - if (screen_modes[n] == mode) - break; - if (n == num_screen_modes) - screen_modes[num_screen_modes++] = mode; + for (m = 0; m < num_modes; m++) { + RRModePtr mode = modes[m]; + int n; + + if (mode->userScreen != pScreen) + continue; + for (n = 0; n < num_screen_modes; n++) + if (screen_modes[n] == mode) + break; + if (n == num_screen_modes) + screen_modes[num_screen_modes++] = mode; } *num_ret = num_screen_modes; @@ -261,184 +264,180 @@ RRModesForScreen (ScreenPtr pScreen, int *num_ret) } void -RRModeDestroy (RRModePtr mode) +RRModeDestroy(RRModePtr mode) { - int m; + int m; if (--mode->refcnt > 0) { #ifdef DEBUG - fprintf(stderr, "RRModeDestroy: mode [%s] ([%p]) refcnt [%d -> %d]\n", mode->name, mode, mode->refcnt + 1, mode->refcnt); + fprintf(stderr, "RRModeDestroy: mode [%s] ([%p]) refcnt [%d -> %d]\n", + mode->name, mode, mode->refcnt + 1, mode->refcnt); #endif - return; + return; } - for (m = 0; m < num_modes; m++) - { - if (modes[m] == mode) - { - memmove (modes + m, modes + m + 1, - (num_modes - m - 1) * sizeof (RRModePtr)); - num_modes--; - if (!num_modes) - { - xfree (modes); - modes = NULL; - } - break; - } + for (m = 0; m < num_modes; m++) { + if (modes[m] == mode) { + memmove(modes + m, modes + m + 1, + (num_modes - m - 1) * sizeof(RRModePtr)); + num_modes--; + if (!num_modes) { + xfree(modes); + modes = NULL; + } + break; + } } #ifdef DEBUG - fprintf(stderr, "RRModeDestroy: destroyed mode [%s] ([%p])\n", mode->name, mode); + fprintf(stderr, "RRModeDestroy: destroyed mode [%s] ([%p])\n", mode->name, + mode); #endif - xfree (mode); + xfree(mode); } static int -RRModeDestroyResource (void * value, XID pid) +RRModeDestroyResource(void *value, XID pid) { #ifdef DEBUG - fprintf(stderr, "RRModeDestroyResource: mode [%s] ([%p]) refcnt [%d]\n", ((RRModePtr)value)->name, (RRModePtr)value, ((RRModePtr)value)->refcnt); + fprintf(stderr, "RRModeDestroyResource: mode [%s] ([%p]) refcnt [%d]\n", + ((RRModePtr) value)->name, (RRModePtr) value, + ((RRModePtr) value)->refcnt); #endif - RRModeDestroy ((RRModePtr) value); + RRModeDestroy((RRModePtr) value); return 1; } Bool -RRModeInit (void) +RRModeInit(void) { - assert (num_modes == 0); - assert (modes == NULL); - RRModeType = CreateNewResourceType (RRModeDestroyResource); + assert(num_modes == 0); + assert(modes == NULL); + RRModeType = CreateNewResourceType(RRModeDestroyResource); if (!RRModeType) - return FALSE; - RegisterResourceName (RRModeType, "MODE"); + return FALSE; + RegisterResourceName(RRModeType, "MODE"); return TRUE; } int -ProcRRCreateMode (ClientPtr client) +ProcRRCreateMode(ClientPtr client) { REQUEST(xRRCreateModeReq); - xRRCreateModeReply rep; - WindowPtr pWin; - ScreenPtr pScreen; - xRRModeInfo *modeInfo; - long units_after; - char *name; - int error, rc; - RRModePtr mode; - - REQUEST_AT_LEAST_SIZE (xRRCreateModeReq); - #ifndef NXAGENT_SERVER + xRRCreateModeReply rep; + WindowPtr pWin; + ScreenPtr pScreen; + xRRModeInfo *modeInfo; + long units_after; + char *name; + int error, rc; + RRModePtr mode; + + REQUEST_AT_LEAST_SIZE(xRRCreateModeReq); +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pWin->drawable.pScreen; modeInfo = &stuff->modeInfo; name = (char *) (stuff + 1); - units_after = (stuff->length - (sizeof (xRRCreateModeReq) >> 2)); + units_after = (stuff->length - (sizeof(xRRCreateModeReq) >> 2)); /* check to make sure requested name fits within the data provided */ if ((int) (modeInfo->nameLength + 3) >> 2 > units_after) - return BadLength; + return BadLength; - mode = RRModeCreateUser (pScreen, modeInfo, name, &error); + mode = RRModeCreateUser(pScreen, modeInfo, name, &error); if (!mode) - return error; + return error; rep.type = X_Reply; rep.pad0 = 0; rep.sequenceNumber = client->sequence; rep.length = 0; rep.mode = mode->mode.id; - if (client->swapped) - { - int n; - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.mode, n); + if (client->swapped) { + int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.mode, n); } - WriteToClient(client, sizeof(xRRCreateModeReply), (char *)&rep); + WriteToClient(client, sizeof(xRRCreateModeReply), (char *) &rep); /* Drop out reference to this mode */ - RRModeDestroy (mode); + RRModeDestroy(mode); return client->noClientException; } int -ProcRRDestroyMode (ClientPtr client) +ProcRRDestroyMode(ClientPtr client) { REQUEST(xRRDestroyModeReq); - RRModePtr mode; + RRModePtr mode; REQUEST_SIZE_MATCH(xRRDestroyModeReq); - mode = LookupIDByType (stuff->mode, RRModeType); - if (!mode) - { - client->errorValue = stuff->mode; - return RRErrorBase + BadRRMode; + mode = LookupIDByType(stuff->mode, RRModeType); + if (!mode) { + client->errorValue = stuff->mode; + return RRErrorBase + BadRRMode; } if (!mode->userScreen) - return BadMatch; + return BadMatch; if (mode->refcnt > 1) - return BadAccess; - FreeResource (stuff->mode, 0); + return BadAccess; + FreeResource(stuff->mode, 0); return Success; } int -ProcRRAddOutputMode (ClientPtr client) +ProcRRAddOutputMode(ClientPtr client) { REQUEST(xRRAddOutputModeReq); - RRModePtr mode; - RROutputPtr output; + RRModePtr mode; + RROutputPtr output; REQUEST_SIZE_MATCH(xRRAddOutputModeReq); output = LookupOutput(client, stuff->output, DixReadAccess); - if (!output) - { - client->errorValue = stuff->output; - return RRErrorBase + BadRROutput; + if (!output) { + client->errorValue = stuff->output; + return RRErrorBase + BadRROutput; } - mode = LookupIDByType (stuff->mode, RRModeType); - if (!mode) - { - client->errorValue = stuff->mode; - return RRErrorBase + BadRRMode; + mode = LookupIDByType(stuff->mode, RRModeType); + if (!mode) { + client->errorValue = stuff->mode; + return RRErrorBase + BadRRMode; } - return RROutputAddUserMode (output, mode); + return RROutputAddUserMode(output, mode); } int -ProcRRDeleteOutputMode (ClientPtr client) +ProcRRDeleteOutputMode(ClientPtr client) { REQUEST(xRRDeleteOutputModeReq); - RRModePtr mode; - RROutputPtr output; + RRModePtr mode; + RROutputPtr output; REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq); output = LookupOutput(client, stuff->output, DixReadAccess); - if (!output) - { - client->errorValue = stuff->output; - return RRErrorBase + BadRROutput; + if (!output) { + client->errorValue = stuff->output; + return RRErrorBase + BadRROutput; } - mode = LookupIDByType (stuff->mode, RRModeType); - if (!mode) - { - client->errorValue = stuff->mode; - return RRErrorBase + BadRRMode; + mode = LookupIDByType(stuff->mode, RRModeType); + if (!mode) { + client->errorValue = stuff->mode; + return RRErrorBase + BadRRMode; } - return RROutputDeleteUserMode (output, mode); + return RROutputDeleteUserMode(output, mode); } diff --git a/nx-X11/programs/Xserver/randr/rroutput.c b/nx-X11/programs/Xserver/randr/rroutput.c index 68c3ce242..523ee55d8 100644 --- a/nx-X11/programs/Xserver/randr/rroutput.c +++ b/nx-X11/programs/Xserver/randr/rroutput.c @@ -23,23 +23,22 @@ #include "randrstr.h" #include "registry.h" -RESTYPE RROutputType; +RESTYPE RROutputType; /* * Notify the output of some change */ void -RROutputChanged (RROutputPtr output, Bool configChanged) +RROutputChanged(RROutputPtr output, Bool configChanged) { - ScreenPtr pScreen = output->pScreen; + ScreenPtr pScreen = output->pScreen; output->changed = TRUE; - if (pScreen) - { - rrScrPriv (pScreen); - pScrPriv->changed = TRUE; - if (configChanged) - pScrPriv->configChanged = TRUE; + if (pScreen) { + rrScrPriv(pScreen); + pScrPriv->changed = TRUE; + if (configChanged) + pScrPriv->configChanged = TRUE; } } @@ -48,38 +47,36 @@ RROutputChanged (RROutputPtr output, Bool configChanged) */ RROutputPtr -RROutputCreate (ScreenPtr pScreen, - const char *name, - int nameLength, - void *devPrivate) +RROutputCreate(ScreenPtr pScreen, + const char *name, int nameLength, void *devPrivate) { - RROutputPtr output; - RROutputPtr *outputs; - rrScrPrivPtr pScrPriv; + RROutputPtr output; + RROutputPtr *outputs; + rrScrPrivPtr pScrPriv; if (!RRInit()) - return NULL; + return NULL; pScrPriv = rrGetScrPriv(pScreen); if (pScrPriv->numOutputs) - outputs = xrealloc (pScrPriv->outputs, - (pScrPriv->numOutputs + 1) * sizeof (RROutputPtr)); + outputs = xrealloc(pScrPriv->outputs, + (pScrPriv->numOutputs + 1) * sizeof(RROutputPtr)); else - outputs = xalloc (sizeof (RROutputPtr)); + outputs = xalloc(sizeof(RROutputPtr)); if (!outputs) - return FALSE; + return FALSE; pScrPriv->outputs = outputs; - output = xalloc (sizeof (RROutputRec) + nameLength + 1); + output = xalloc(sizeof(RROutputRec) + nameLength + 1); if (!output) - return NULL; - output->id = FakeClientID (0); + return NULL; + output->id = FakeClientID(0); output->pScreen = pScreen; output->name = (char *) (output + 1); output->nameLength = nameLength; - memcpy (output->name, name, nameLength); + memcpy(output->name, name, nameLength); output->name[nameLength] = '\0'; output->connection = RR_UnknownConnection; output->subpixelOrder = SubPixelUnknown; @@ -100,8 +97,8 @@ RROutputCreate (ScreenPtr pScreen, output->changed = FALSE; output->devPrivate = devPrivate; - if (!AddResource (output->id, RROutputType, (void *) output)) - return NULL; + if (!AddResource(output->id, RROutputType, (void *) output)) + return NULL; pScrPriv->outputs[pScrPriv->numOutputs++] = output; return output; @@ -111,229 +108,208 @@ RROutputCreate (ScreenPtr pScreen, * Notify extension that output parameters have been changed */ Bool -RROutputSetClones (RROutputPtr output, - RROutputPtr *clones, - int numClones) +RROutputSetClones(RROutputPtr output, RROutputPtr * clones, int numClones) { - RROutputPtr *newClones; - int i; - - if (numClones == output->numClones) - { - for (i = 0; i < numClones; i++) - if (output->clones[i] != clones[i]) - break; - if (i == numClones) - return TRUE; + RROutputPtr *newClones; + int i; + + if (numClones == output->numClones) { + for (i = 0; i < numClones; i++) + if (output->clones[i] != clones[i]) + break; + if (i == numClones) + return TRUE; } - if (numClones) - { - newClones = xalloc (numClones * sizeof (RROutputPtr)); - if (!newClones) - return FALSE; + if (numClones) { + newClones = xalloc(numClones * sizeof(RROutputPtr)); + if (!newClones) + return FALSE; } else - newClones = NULL; + newClones = NULL; if (output->clones) - xfree (output->clones); - memcpy (newClones, clones, numClones * sizeof (RROutputPtr)); + xfree(output->clones); + memcpy(newClones, clones, numClones * sizeof(RROutputPtr)); output->clones = newClones; output->numClones = numClones; - RROutputChanged (output, TRUE); + RROutputChanged(output, TRUE); return TRUE; } Bool -RROutputSetModes (RROutputPtr output, - RRModePtr *modes, - int numModes, - int numPreferred) +RROutputSetModes(RROutputPtr output, + RRModePtr * modes, int numModes, int numPreferred) { - RRModePtr *newModes; - int i; - - if (numModes == output->numModes && numPreferred == output->numPreferred) - { - for (i = 0; i < numModes; i++) - if (output->modes[i] != modes[i]) - break; - if (i == numModes) - { - for (i = 0; i < numModes; i++) - RRModeDestroy (modes[i]); - return TRUE; - } + RRModePtr *newModes; + int i; + + if (numModes == output->numModes && numPreferred == output->numPreferred) { + for (i = 0; i < numModes; i++) + if (output->modes[i] != modes[i]) + break; + if (i == numModes) { + for (i = 0; i < numModes; i++) + RRModeDestroy(modes[i]); + return TRUE; + } } - if (numModes) - { - newModes = xalloc (numModes * sizeof (RRModePtr)); - if (!newModes) - return FALSE; + if (numModes) { + newModes = xalloc(numModes * sizeof(RRModePtr)); + if (!newModes) + return FALSE; } else - newModes = NULL; - if (output->modes) - { - for (i = 0; i < output->numModes; i++) - RRModeDestroy (output->modes[i]); - xfree (output->modes); + newModes = NULL; + if (output->modes) { + for (i = 0; i < output->numModes; i++) + RRModeDestroy(output->modes[i]); + xfree(output->modes); } - memcpy (newModes, modes, numModes * sizeof (RRModePtr)); + memcpy(newModes, modes, numModes * sizeof(RRModePtr)); output->modes = newModes; output->numModes = numModes; output->numPreferred = numPreferred; - RROutputChanged (output, TRUE); + RROutputChanged(output, TRUE); return TRUE; } int -RROutputAddUserMode (RROutputPtr output, - RRModePtr mode) +RROutputAddUserMode(RROutputPtr output, RRModePtr mode) { - int m; - ScreenPtr pScreen = output->pScreen; + int m; + ScreenPtr pScreen = output->pScreen; + rrScrPriv(pScreen); - RRModePtr *newModes; + RRModePtr *newModes; /* Check to see if this mode is already listed for this output */ - for (m = 0; m < output->numModes + output->numUserModes; m++) - { - RRModePtr e = (m < output->numModes ? - output->modes[m] : - output->userModes[m - output->numModes]); - if (mode == e) - return Success; + for (m = 0; m < output->numModes + output->numUserModes; m++) { + RRModePtr e = (m < output->numModes ? + output->modes[m] : + output->userModes[m - output->numModes]); + if (mode == e) + return Success; } /* Check with the DDX to see if this mode is OK */ if (pScrPriv->rrOutputValidateMode) - if (!pScrPriv->rrOutputValidateMode (pScreen, output, mode)) - return BadMatch; + if (!pScrPriv->rrOutputValidateMode(pScreen, output, mode)) + return BadMatch; if (output->userModes) - newModes = xrealloc (output->userModes, - (output->numUserModes + 1) * sizeof (RRModePtr)); + newModes = xrealloc(output->userModes, + (output->numUserModes + 1) * sizeof(RRModePtr)); else - newModes = xalloc (sizeof (RRModePtr)); + newModes = xalloc(sizeof(RRModePtr)); if (!newModes) - return BadAlloc; + return BadAlloc; output->userModes = newModes; output->userModes[output->numUserModes++] = mode; ++mode->refcnt; - RROutputChanged (output, TRUE); - RRTellChanged (pScreen); + RROutputChanged(output, TRUE); + RRTellChanged(pScreen); return Success; } int -RROutputDeleteUserMode (RROutputPtr output, - RRModePtr mode) +RROutputDeleteUserMode(RROutputPtr output, RRModePtr mode) { - int m; + int m; /* Find this mode in the user mode list */ - for (m = 0; m < output->numUserModes; m++) - { - RRModePtr e = output->userModes[m]; + for (m = 0; m < output->numUserModes; m++) { + RRModePtr e = output->userModes[m]; - if (mode == e) - break; + if (mode == e) + break; } /* Not there, access error */ if (m == output->numUserModes) - return BadAccess; + return BadAccess; /* make sure the mode isn't active for this output */ if (output->crtc && output->crtc->mode == mode) - return BadMatch; + return BadMatch; - memmove (output->userModes + m, output->userModes + m + 1, - (output->numUserModes - m - 1) * sizeof (RRModePtr)); + memmove(output->userModes + m, output->userModes + m + 1, + (output->numUserModes - m - 1) * sizeof(RRModePtr)); output->numUserModes--; - RRModeDestroy (mode); + RRModeDestroy(mode); return Success; } Bool -RROutputSetCrtcs (RROutputPtr output, - RRCrtcPtr *crtcs, - int numCrtcs) +RROutputSetCrtcs(RROutputPtr output, RRCrtcPtr * crtcs, int numCrtcs) { - RRCrtcPtr *newCrtcs; - int i; - - if (numCrtcs == output->numCrtcs) - { - for (i = 0; i < numCrtcs; i++) - if (output->crtcs[i] != crtcs[i]) - break; - if (i == numCrtcs) - return TRUE; + RRCrtcPtr *newCrtcs; + int i; + + if (numCrtcs == output->numCrtcs) { + for (i = 0; i < numCrtcs; i++) + if (output->crtcs[i] != crtcs[i]) + break; + if (i == numCrtcs) + return TRUE; } - if (numCrtcs) - { - newCrtcs = xalloc (numCrtcs * sizeof (RRCrtcPtr)); - if (!newCrtcs) - return FALSE; + if (numCrtcs) { + newCrtcs = xalloc(numCrtcs * sizeof(RRCrtcPtr)); + if (!newCrtcs) + return FALSE; } else - newCrtcs = NULL; + newCrtcs = NULL; if (output->crtcs) - xfree (output->crtcs); - memcpy (newCrtcs, crtcs, numCrtcs * sizeof (RRCrtcPtr)); + xfree(output->crtcs); + memcpy(newCrtcs, crtcs, numCrtcs * sizeof(RRCrtcPtr)); output->crtcs = newCrtcs; output->numCrtcs = numCrtcs; - RROutputChanged (output, TRUE); + RROutputChanged(output, TRUE); return TRUE; } Bool -RROutputSetConnection (RROutputPtr output, - CARD8 connection) +RROutputSetConnection(RROutputPtr output, CARD8 connection) { if (output->connection == connection) - return TRUE; + return TRUE; output->connection = connection; - RROutputChanged (output, TRUE); + RROutputChanged(output, TRUE); return TRUE; } Bool -RROutputSetSubpixelOrder (RROutputPtr output, - int subpixelOrder) +RROutputSetSubpixelOrder(RROutputPtr output, int subpixelOrder) { if (output->subpixelOrder == subpixelOrder) - return TRUE; + return TRUE; output->subpixelOrder = subpixelOrder; - RROutputChanged (output, FALSE); + RROutputChanged(output, FALSE); return TRUE; } Bool -RROutputSetPhysicalSize (RROutputPtr output, - int mmWidth, - int mmHeight) +RROutputSetPhysicalSize(RROutputPtr output, int mmWidth, int mmHeight) { if (output->mmWidth == mmWidth && output->mmHeight == mmHeight) - return TRUE; + return TRUE; output->mmWidth = mmWidth; output->mmHeight = mmHeight; - RROutputChanged (output, FALSE); + RROutputChanged(output, FALSE); return TRUE; } - void RRDeliverOutputEvent(ClientPtr client, WindowPtr pWin, RROutputPtr output) { ScreenPtr pScreen = pWin->drawable.pScreen; - rrScrPriv (pScreen); - xRROutputChangeNotifyEvent oe; - RRCrtcPtr crtc = output->crtc; - RRModePtr mode = crtc ? crtc->mode : 0; + + rrScrPriv(pScreen); + xRROutputChangeNotifyEvent oe; + RRCrtcPtr crtc = output->crtc; + RRModePtr mode = crtc ? crtc->mode : 0; oe.type = RRNotify + RREventBase; oe.subCode = RRNotify_OutputChange; @@ -342,73 +318,67 @@ RRDeliverOutputEvent(ClientPtr client, WindowPtr pWin, RROutputPtr output) oe.configTimestamp = pScrPriv->lastConfigTime.milliseconds; oe.window = pWin->drawable.id; oe.output = output->id; - if (crtc) - { - oe.crtc = crtc->id; - oe.mode = mode ? mode->mode.id : None; - oe.rotation = crtc->rotation; + if (crtc) { + oe.crtc = crtc->id; + oe.mode = mode ? mode->mode.id : None; + oe.rotation = crtc->rotation; } - else - { - oe.crtc = None; - oe.mode = None; - oe.rotation = RR_Rotate_0; + else { + oe.crtc = None; + oe.mode = None; + oe.rotation = RR_Rotate_0; } oe.connection = output->connection; oe.subpixelOrder = output->subpixelOrder; - WriteEventsToClient (client, 1, (xEvent *) &oe); + WriteEventsToClient(client, 1, (xEvent *) &oe); } /* * Destroy a Output at shutdown */ void -RROutputDestroy (RROutputPtr output) +RROutputDestroy(RROutputPtr output) { - FreeResource (output->id, 0); + FreeResource(output->id, 0); } static int -RROutputDestroyResource (void * value, XID pid) +RROutputDestroyResource(void *value, XID pid) { - RROutputPtr output = (RROutputPtr) value; - ScreenPtr pScreen = output->pScreen; - int m; - - if (pScreen) - { - rrScrPriv(pScreen); - int i; - - for (i = 0; i < pScrPriv->numOutputs; i++) - { - if (pScrPriv->outputs[i] == output) - { - memmove (pScrPriv->outputs + i, pScrPriv->outputs + i + 1, - (pScrPriv->numOutputs - (i + 1)) * sizeof (RROutputPtr)); - --pScrPriv->numOutputs; - break; - } - } + RROutputPtr output = (RROutputPtr) value; + ScreenPtr pScreen = output->pScreen; + int m; + + if (pScreen) { + rrScrPriv(pScreen); + int i; + + for (i = 0; i < pScrPriv->numOutputs; i++) { + if (pScrPriv->outputs[i] == output) { + memmove(pScrPriv->outputs + i, pScrPriv->outputs + i + 1, + (pScrPriv->numOutputs - (i + 1)) * sizeof(RROutputPtr)); + --pScrPriv->numOutputs; + break; + } + } } - if (output->modes) - { - for (m = 0; m < output->numModes; m++) - RRModeDestroy (output->modes[m]); - xfree (output->modes); + if (output->modes) { + for (m = 0; m < output->numModes; m++) + RRModeDestroy(output->modes[m]); + xfree(output->modes); } for (m = 0; m < output->numUserModes; m++) - RRModeDestroy (output->userModes[m]); + RRModeDestroy(output->userModes[m]); if (output->userModes) - xfree (output->userModes); + xfree(output->userModes); if (output->crtcs) - xfree (output->crtcs); + xfree(output->crtcs); if (output->clones) - xfree (output->clones); - RRDeleteAllOutputProperties (output); - xfree (output); + xfree(output->clones); + RRDeleteAllOutputProperties(output); + xfree(output); return 1; } @@ -416,40 +386,39 @@ RROutputDestroyResource (void * value, XID pid) * Initialize output type */ Bool -RROutputInit (void) +RROutputInit(void) { - RROutputType = CreateNewResourceType (RROutputDestroyResource); + RROutputType = CreateNewResourceType(RROutputDestroyResource); if (!RROutputType) - return FALSE; - RegisterResourceName (RROutputType, "OUTPUT"); + return FALSE; + RegisterResourceName(RROutputType, "OUTPUT"); return TRUE; } #define OutputInfoExtra (SIZEOF(xRRGetOutputInfoReply) - 32) - + int -ProcRRGetOutputInfo (ClientPtr client) +ProcRRGetOutputInfo(ClientPtr client) { REQUEST(xRRGetOutputInfoReq); - xRRGetOutputInfoReply rep; - RROutputPtr output; - CARD8 *extra; - unsigned long extraLen; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - RRCrtc *crtcs; - RRMode *modes; - RROutput *clones; - char *name; - int i, n; + xRRGetOutputInfoReply rep; + RROutputPtr output; + CARD8 *extra; + unsigned long extraLen; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + RRCrtc *crtcs; + RRMode *modes; + RROutput *clones; + char *name; + int i, n; REQUEST_SIZE_MATCH(xRRGetOutputInfoReq); output = LookupOutput(client, stuff->output, DixReadAccess); - if (!output) - { - client->errorValue = stuff->output; - return RRErrorBase + BadRROutput; + if (!output) { + client->errorValue = stuff->output; + return RRErrorBase + BadRROutput; } pScreen = output->pScreen; @@ -472,64 +441,58 @@ ProcRRGetOutputInfo (ClientPtr client) rep.nameLength = output->nameLength; extraLen = ((output->numCrtcs + - output->numModes + output->numUserModes + - output->numClones + - ((rep.nameLength + 3) >> 2)) << 2); - - if (extraLen) - { - rep.length += extraLen >> 2; - extra = xalloc (extraLen); - if (!extra) - return BadAlloc; + output->numModes + output->numUserModes + + output->numClones + ((rep.nameLength + 3) >> 2)) << 2); + + if (extraLen) { + rep.length += extraLen >> 2; + extra = xalloc(extraLen); + if (!extra) + return BadAlloc; } else - extra = NULL; + extra = NULL; crtcs = (RRCrtc *) extra; modes = (RRMode *) (crtcs + output->numCrtcs); clones = (RROutput *) (modes + output->numModes + output->numUserModes); name = (char *) (clones + output->numClones); - for (i = 0; i < output->numCrtcs; i++) - { - crtcs[i] = output->crtcs[i]->id; - if (client->swapped) - swapl (&crtcs[i], n); + for (i = 0; i < output->numCrtcs; i++) { + crtcs[i] = output->crtcs[i]->id; + if (client->swapped) + swapl(&crtcs[i], n); } - for (i = 0; i < output->numModes + output->numUserModes; i++) - { - if (i < output->numModes) - modes[i] = output->modes[i]->mode.id; - else - modes[i] = output->userModes[i - output->numModes]->mode.id; - if (client->swapped) - swapl (&modes[i], n); + for (i = 0; i < output->numModes + output->numUserModes; i++) { + if (i < output->numModes) + modes[i] = output->modes[i]->mode.id; + else + modes[i] = output->userModes[i - output->numModes]->mode.id; + if (client->swapped) + swapl(&modes[i], n); } - for (i = 0; i < output->numClones; i++) - { - clones[i] = output->clones[i]->id; - if (client->swapped) - swapl (&clones[i], n); + for (i = 0; i < output->numClones; i++) { + clones[i] = output->clones[i]->id; + if (client->swapped) + swapl(&clones[i], n); } - memcpy (name, output->name, output->nameLength); + memcpy(name, output->name, output->nameLength); if (client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.timestamp, n); - swapl(&rep.crtc, n); - swapl(&rep.mmWidth, n); - swapl(&rep.mmHeight, n); - swaps(&rep.nCrtcs, n); - swaps(&rep.nModes, n); - swaps(&rep.nClones, n); - swaps(&rep.nameLength, n); + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.timestamp, n); + swapl(&rep.crtc, n); + swapl(&rep.mmWidth, n); + swapl(&rep.mmHeight, n); + swaps(&rep.nCrtcs, n); + swaps(&rep.nModes, n); + swaps(&rep.nClones, n); + swaps(&rep.nameLength, n); } - WriteToClient(client, sizeof(xRRGetOutputInfoReply), (char *)&rep); - if (extraLen) - { - WriteToClient (client, extraLen, (char *) extra); - xfree (extra); + WriteToClient(client, sizeof(xRRGetOutputInfoReply), (char *) &rep); + if (extraLen) { + WriteToClient(client, extraLen, (char *) extra); + xfree(extra); } return client->noClientException; diff --git a/nx-X11/programs/Xserver/randr/rrpointer.c b/nx-X11/programs/Xserver/randr/rrpointer.c index 09ce70212..811310985 100644 --- a/nx-X11/programs/Xserver/randr/rrpointer.c +++ b/nx-X11/programs/Xserver/randr/rrpointer.c @@ -31,19 +31,19 @@ */ static Bool -RRCrtcContainsPosition (RRCrtcPtr crtc, int x, int y) +RRCrtcContainsPosition(RRCrtcPtr crtc, int x, int y) { - RRModePtr mode = crtc->mode; - int scan_width, scan_height; + RRModePtr mode = crtc->mode; + int scan_width, scan_height; if (!mode) - return FALSE; + return FALSE; - RRCrtcGetScanoutSize (crtc, &scan_width, &scan_height); + RRCrtcGetScanoutSize(crtc, &scan_width, &scan_height); if (crtc->x <= x && x < crtc->x + scan_width && - crtc->y <= y && y < crtc->y + scan_height) - return TRUE; + crtc->y <= y && y < crtc->y + scan_height) + return TRUE; return FALSE; } @@ -51,80 +51,76 @@ RRCrtcContainsPosition (RRCrtcPtr crtc, int x, int y) * Find the CRTC nearest the specified position, ignoring 'skip' */ static void -RRPointerToNearestCrtc (ScreenPtr pScreen, int x, int y, RRCrtcPtr skip) +RRPointerToNearestCrtc(ScreenPtr pScreen, int x, int y, RRCrtcPtr skip) { - rrScrPriv (pScreen); - int c; - RRCrtcPtr nearest = NULL; - int best = 0; - int best_dx = 0, best_dy = 0; - - for (c = 0; c < pScrPriv->numCrtcs; c++) - { - RRCrtcPtr crtc = pScrPriv->crtcs[c]; - RRModePtr mode = crtc->mode; - int dx, dy; - int dist; - int scan_width, scan_height; - - if (!mode) - continue; - if (crtc == skip) - continue; - - RRCrtcGetScanoutSize (crtc, &scan_width, &scan_height); - - if (x < crtc->x) - dx = crtc->x - x; - else if (x > crtc->x + scan_width) - dx = x - (crtc->x + scan_width); - else - dx = 0; - if (y < crtc->y) - dy = crtc->y - x; - else if (y > crtc->y + scan_height) - dy = y - (crtc->y + scan_height); - else - dy = 0; - dist = dx + dy; - if (!nearest || dist < best) - { - nearest = crtc; - best_dx = dx; - best_dy = dy; - } + rrScrPriv(pScreen); + int c; + RRCrtcPtr nearest = NULL; + int best = 0; + int best_dx = 0, best_dy = 0; + + for (c = 0; c < pScrPriv->numCrtcs; c++) { + RRCrtcPtr crtc = pScrPriv->crtcs[c]; + RRModePtr mode = crtc->mode; + int dx, dy; + int dist; + int scan_width, scan_height; + + if (!mode) + continue; + if (crtc == skip) + continue; + + RRCrtcGetScanoutSize(crtc, &scan_width, &scan_height); + + if (x < crtc->x) + dx = crtc->x - x; + else if (x > crtc->x + scan_width) + dx = x - (crtc->x + scan_width); + else + dx = 0; + if (y < crtc->y) + dy = crtc->y - x; + else if (y > crtc->y + scan_height) + dy = y - (crtc->y + scan_height); + else + dy = 0; + dist = dx + dy; + if (!nearest || dist < best) { + nearest = crtc; + best_dx = dx; + best_dy = dy; + } } if (best_dx || best_dy) - (*pScreen->SetCursorPosition) (pScreen, x + best_dx, y + best_dy, TRUE); + (*pScreen->SetCursorPosition) (pScreen, x + best_dx, y + best_dy, TRUE); pScrPriv->pointerCrtc = nearest; } void -RRPointerMoved (ScreenPtr pScreen, int x, int y) +RRPointerMoved(ScreenPtr pScreen, int x, int y) { - rrScrPriv (pScreen); - RRCrtcPtr pointerCrtc = pScrPriv->pointerCrtc; - int c; + rrScrPriv(pScreen); + RRCrtcPtr pointerCrtc = pScrPriv->pointerCrtc; + int c; /* Check last known CRTC */ - if (pointerCrtc && RRCrtcContainsPosition (pointerCrtc, x, y)) - return; + if (pointerCrtc && RRCrtcContainsPosition(pointerCrtc, x, y)) + return; /* Check all CRTCs */ - for (c = 0; c < pScrPriv->numCrtcs; c++) - { - RRCrtcPtr crtc = pScrPriv->crtcs[c]; - - if (RRCrtcContainsPosition (crtc, x, y)) - { - /* Remember containing CRTC */ - pScrPriv->pointerCrtc = crtc; - return; - } + for (c = 0; c < pScrPriv->numCrtcs; c++) { + RRCrtcPtr crtc = pScrPriv->crtcs[c]; + + if (RRCrtcContainsPosition(crtc, x, y)) { + /* Remember containing CRTC */ + pScrPriv->pointerCrtc = crtc; + return; + } } /* None contain pointer, find nearest */ - RRPointerToNearestCrtc (pScreen, x, y, pointerCrtc); + RRPointerToNearestCrtc(pScreen, x, y, pointerCrtc); } /* @@ -132,14 +128,14 @@ RRPointerMoved (ScreenPtr pScreen, int x, int y) * CRTC */ void -RRPointerScreenConfigured (ScreenPtr pScreen) +RRPointerScreenConfigured(ScreenPtr pScreen) { - WindowPtr pRoot = GetCurrentRootWindow (); - ScreenPtr pCurrentScreen = pRoot ? pRoot->drawable.pScreen : NULL; - int x, y; + WindowPtr pRoot = GetCurrentRootWindow(); + ScreenPtr pCurrentScreen = pRoot ? pRoot->drawable.pScreen : NULL; + int x, y; if (pScreen != pCurrentScreen) - return; - GetSpritePosition (&x, &y); - RRPointerToNearestCrtc (pScreen, x, y, NULL); + return; + GetSpritePosition(&x, &y); + RRPointerToNearestCrtc(pScreen, x, y, NULL); } diff --git a/nx-X11/programs/Xserver/randr/rrproperty.c b/nx-X11/programs/Xserver/randr/rrproperty.c index 5d39d1402..0bccb0c68 100644 --- a/nx-X11/programs/Xserver/randr/rrproperty.c +++ b/nx-X11/programs/Xserver/randr/rrproperty.c @@ -25,37 +25,37 @@ #include "swaprep.h" static void -RRDeliverEvent (ScreenPtr pScreen, xEvent *event, CARD32 mask) +RRDeliverEvent(ScreenPtr pScreen, xEvent *event, CARD32 mask) { } void -RRDeleteAllOutputProperties (RROutputPtr output) +RRDeleteAllOutputProperties(RROutputPtr output) { RRPropertyPtr prop, next; - xRROutputPropertyNotifyEvent event; - - for (prop = output->properties; prop; prop = next) - { - next = prop->next; - event.type = RREventBase + RRNotify; - event.subCode = RRNotify_OutputProperty; - event.output = output->id; - event.state = PropertyDelete; - event.atom = prop->propertyName; - event.timestamp = currentTime.milliseconds; - RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask); - if (prop->current.data) - xfree(prop->current.data); - if (prop->pending.data) - xfree(prop->pending.data); - xfree(prop); + xRROutputPropertyNotifyEvent event; + + for (prop = output->properties; prop; prop = next) { + next = prop->next; + event.type = RREventBase + RRNotify; + event.subCode = RRNotify_OutputProperty; + event.output = output->id; + event.state = PropertyDelete; + event.atom = prop->propertyName; + event.timestamp = currentTime.milliseconds; + RRDeliverEvent(output->pScreen, (xEvent *) &event, + RROutputPropertyNotifyMask); + if (prop->current.data) + xfree(prop->current.data); + if (prop->pending.data) + xfree(prop->pending.data); + xfree(prop); } } static void -RRInitOutputPropertyValue (RRPropertyValuePtr property_value) +RRInitOutputPropertyValue(RRPropertyValuePtr property_value) { property_value->type = None; property_value->format = 0; @@ -64,13 +64,13 @@ RRInitOutputPropertyValue (RRPropertyValuePtr property_value) } static RRPropertyPtr -RRCreateOutputProperty (Atom property) +RRCreateOutputProperty(Atom property) { - RRPropertyPtr prop; + RRPropertyPtr prop; - prop = (RRPropertyPtr)xalloc(sizeof(RRPropertyRec)); + prop = (RRPropertyPtr) xalloc(sizeof(RRPropertyRec)); if (!prop) - return NULL; + return NULL; prop->next = NULL; prop->propertyName = property; prop->is_pending = FALSE; @@ -78,276 +78,267 @@ RRCreateOutputProperty (Atom property) prop->immutable = FALSE; prop->num_valid = 0; prop->valid_values = NULL; - RRInitOutputPropertyValue (&prop->current); - RRInitOutputPropertyValue (&prop->pending); + RRInitOutputPropertyValue(&prop->current); + RRInitOutputPropertyValue(&prop->pending); return prop; } static void -RRDestroyOutputProperty (RRPropertyPtr prop) +RRDestroyOutputProperty(RRPropertyPtr prop) { if (prop->valid_values) - xfree (prop->valid_values); + xfree(prop->valid_values); if (prop->current.data) - xfree(prop->current.data); + xfree(prop->current.data); if (prop->pending.data) - xfree(prop->pending.data); + xfree(prop->pending.data); xfree(prop); } void -RRDeleteOutputProperty (RROutputPtr output, Atom property) +RRDeleteOutputProperty(RROutputPtr output, Atom property) { - RRPropertyPtr prop, *prev; - xRROutputPropertyNotifyEvent event; + RRPropertyPtr prop, *prev; + xRROutputPropertyNotifyEvent event; for (prev = &output->properties; (prop = *prev); prev = &(prop->next)) - if (prop->propertyName == property) - break; - if (prop) - { - *prev = prop->next; - event.type = RREventBase + RRNotify; - event.subCode = RRNotify_OutputProperty; - event.output = output->id; - event.state = PropertyDelete; - event.atom = prop->propertyName; - event.timestamp = currentTime.milliseconds; - RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask); - RRDestroyOutputProperty (prop); + if (prop->propertyName == property) + break; + if (prop) { + *prev = prop->next; + event.type = RREventBase + RRNotify; + event.subCode = RRNotify_OutputProperty; + event.output = output->id; + event.state = PropertyDelete; + event.atom = prop->propertyName; + event.timestamp = currentTime.milliseconds; + RRDeliverEvent(output->pScreen, (xEvent *) &event, + RROutputPropertyNotifyMask); + RRDestroyOutputProperty(prop); } } int -RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type, - int format, int mode, unsigned long len, - void * value, Bool sendevent, Bool pending) +RRChangeOutputProperty(RROutputPtr output, Atom property, Atom type, + int format, int mode, unsigned long len, + void *value, Bool sendevent, Bool pending) { - RRPropertyPtr prop; - xRROutputPropertyNotifyEvent event; - rrScrPrivPtr pScrPriv = rrGetScrPriv(output->pScreen); - int size_in_bytes; - int total_size; - unsigned long total_len; - RRPropertyValuePtr prop_value; - RRPropertyValueRec new_value; - Bool add = FALSE; + RRPropertyPtr prop; + xRROutputPropertyNotifyEvent event; + rrScrPrivPtr pScrPriv = rrGetScrPriv(output->pScreen); + int size_in_bytes; + int total_size; + unsigned long total_len; + RRPropertyValuePtr prop_value; + RRPropertyValueRec new_value; + Bool add = FALSE; size_in_bytes = format >> 3; /* first see if property already exists */ - prop = RRQueryOutputProperty (output, property); - if (!prop) /* just add to list */ - { - prop = RRCreateOutputProperty (property); - if (!prop) - return(BadAlloc); - add = TRUE; - mode = PropModeReplace; + prop = RRQueryOutputProperty(output, property); + if (!prop) { /* just add to list */ + prop = RRCreateOutputProperty(property); + if (!prop) + return (BadAlloc); + add = TRUE; + mode = PropModeReplace; } if (pending && prop->is_pending) - prop_value = &prop->pending; + prop_value = &prop->pending; else - prop_value = &prop->current; + prop_value = &prop->current; /* To append or prepend to a property the request format and type - must match those of the already defined property. The - existing format and type are irrelevant when using the mode - "PropModeReplace" since they will be written over. */ + must match those of the already defined property. The + existing format and type are irrelevant when using the mode + "PropModeReplace" since they will be written over. */ if ((format != prop_value->format) && (mode != PropModeReplace)) - return(BadMatch); + return (BadMatch); if ((prop_value->type != type) && (mode != PropModeReplace)) - return(BadMatch); + return (BadMatch); new_value = *prop_value; if (mode == PropModeReplace) - total_len = len; + total_len = len; else - total_len = prop_value->size + len; - - if (mode == PropModeReplace || len > 0) - { - void *new_data = NULL, *old_data = NULL; - - total_size = total_len * size_in_bytes; - new_value.data = (void *)xalloc (total_size); - if (!new_value.data && total_size) - { - if (add) - RRDestroyOutputProperty (prop); - return BadAlloc; - } - new_value.size = len; - new_value.type = type; - new_value.format = format; - - switch (mode) { - case PropModeReplace: - new_data = new_value.data; - old_data = NULL; - break; - case PropModeAppend: - new_data = (void *) (((char *) new_value.data) + - (prop_value->size * size_in_bytes)); - old_data = new_value.data; - break; - case PropModePrepend: - new_data = new_value.data; - old_data = (void *) (((char *) new_value.data) + - (prop_value->size * size_in_bytes)); - break; - } - if (new_data) - memcpy ((char *) new_data, (char *) value, len * size_in_bytes); - if (old_data) - memcpy ((char *) old_data, (char *) prop_value->data, - prop_value->size * size_in_bytes); - - if (pending && pScrPriv->rrOutputSetProperty && - !pScrPriv->rrOutputSetProperty(output->pScreen, output, - prop->propertyName, &new_value)) - { - if (new_value.data) - xfree (new_value.data); - return (BadValue); - } - if (prop_value->data) - xfree (prop_value->data); - *prop_value = new_value; - } - - else if (len == 0) - { - /* do nothing */ - } - - if (add) - { - prop->next = output->properties; - output->properties = prop; + total_len = prop_value->size + len; + + if (mode == PropModeReplace || len > 0) { + void *new_data = NULL, *old_data = NULL; + + total_size = total_len * size_in_bytes; + new_value.data = (void *) xalloc(total_size); + if (!new_value.data && total_size) { + if (add) + RRDestroyOutputProperty(prop); + return BadAlloc; + } + new_value.size = len; + new_value.type = type; + new_value.format = format; + + switch (mode) { + case PropModeReplace: + new_data = new_value.data; + old_data = NULL; + break; + case PropModeAppend: + new_data = (void *) (((char *) new_value.data) + + (prop_value->size * size_in_bytes)); + old_data = new_value.data; + break; + case PropModePrepend: + new_data = new_value.data; + old_data = (void *) (((char *) new_value.data) + + (prop_value->size * size_in_bytes)); + break; + } + if (new_data) + memcpy((char *) new_data, (char *) value, len * size_in_bytes); + if (old_data) + memcpy((char *) old_data, (char *) prop_value->data, + prop_value->size * size_in_bytes); + + if (pending && pScrPriv->rrOutputSetProperty && + !pScrPriv->rrOutputSetProperty(output->pScreen, output, + prop->propertyName, &new_value)) { + if (new_value.data) + xfree(new_value.data); + return (BadValue); + } + if (prop_value->data) + xfree(prop_value->data); + *prop_value = new_value; + } + + else if (len == 0) { + /* do nothing */ + } + + if (add) { + prop->next = output->properties; + output->properties = prop; } if (pending && prop->is_pending) - output->pendingProperties = TRUE; - - if (sendevent) - { - event.type = RREventBase + RRNotify; - event.subCode = RRNotify_OutputProperty; - event.output = output->id; - event.state = PropertyNewValue; - event.atom = prop->propertyName; - event.timestamp = currentTime.milliseconds; - RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask); - } - return(Success); + output->pendingProperties = TRUE; + + if (sendevent) { + event.type = RREventBase + RRNotify; + event.subCode = RRNotify_OutputProperty; + event.output = output->id; + event.state = PropertyNewValue; + event.atom = prop->propertyName; + event.timestamp = currentTime.milliseconds; + RRDeliverEvent(output->pScreen, (xEvent *) &event, + RROutputPropertyNotifyMask); + } + return (Success); } Bool -RRPostPendingProperties (RROutputPtr output) +RRPostPendingProperties(RROutputPtr output) { - RRPropertyValuePtr pending_value; - RRPropertyValuePtr current_value; - RRPropertyPtr property; - Bool ret = TRUE; + RRPropertyValuePtr pending_value; + RRPropertyValuePtr current_value; + RRPropertyPtr property; + Bool ret = TRUE; if (!output->pendingProperties) - return TRUE; + return TRUE; output->pendingProperties = FALSE; - for (property = output->properties; property; property = property->next) - { - /* Skip non-pending properties */ - if (!property->is_pending) - continue; - - pending_value = &property->pending; - current_value = &property->current; - - /* - * If the pending and current values are equal, don't mark it - * as changed (which would deliver an event) - */ - if (pending_value->type == current_value->type && - pending_value->format == current_value->format && - pending_value->size == current_value->size && - !memcmp (pending_value->data, current_value->data, - pending_value->size)) - continue; - - if (RRChangeOutputProperty (output, property->propertyName, - pending_value->type, pending_value->format, - PropModeReplace, pending_value->size, - pending_value->data, TRUE, - FALSE) != Success) - ret = FALSE; + for (property = output->properties; property; property = property->next) { + /* Skip non-pending properties */ + if (!property->is_pending) + continue; + + pending_value = &property->pending; + current_value = &property->current; + + /* + * If the pending and current values are equal, don't mark it + * as changed (which would deliver an event) + */ + if (pending_value->type == current_value->type && + pending_value->format == current_value->format && + pending_value->size == current_value->size && + !memcmp(pending_value->data, current_value->data, + pending_value->size)) + continue; + + if (RRChangeOutputProperty(output, property->propertyName, + pending_value->type, pending_value->format, + PropModeReplace, pending_value->size, + pending_value->data, TRUE, FALSE) != Success) + ret = FALSE; } return ret; } RRPropertyPtr -RRQueryOutputProperty (RROutputPtr output, Atom property) +RRQueryOutputProperty(RROutputPtr output, Atom property) { - RRPropertyPtr prop; + RRPropertyPtr prop; for (prop = output->properties; prop; prop = prop->next) - if (prop->propertyName == property) - return prop; + if (prop->propertyName == property) + return prop; return NULL; } - + RRPropertyValuePtr -RRGetOutputProperty (RROutputPtr output, Atom property, Bool pending) +RRGetOutputProperty(RROutputPtr output, Atom property, Bool pending) { - RRPropertyPtr prop = RRQueryOutputProperty (output, property); + RRPropertyPtr prop = RRQueryOutputProperty(output, property); if (!prop) - return NULL; + return NULL; if (pending && prop->is_pending) - return &prop->pending; + return &prop->pending; else - return &prop->current; + return &prop->current; } int -RRConfigureOutputProperty (RROutputPtr output, Atom property, - Bool pending, Bool range, Bool immutable, - int num_values, INT32 *values) +RRConfigureOutputProperty(RROutputPtr output, Atom property, + Bool pending, Bool range, Bool immutable, + int num_values, INT32 *values) { - RRPropertyPtr prop = RRQueryOutputProperty (output, property); - Bool add = FALSE; - INT32 *new_values; - - if (!prop) - { - prop = RRCreateOutputProperty (property); - if (!prop) - return(BadAlloc); - add = TRUE; - } else if (prop->immutable && !immutable) - return(BadAccess); + RRPropertyPtr prop = RRQueryOutputProperty(output, property); + Bool add = FALSE; + INT32 *new_values; + + if (!prop) { + prop = RRCreateOutputProperty(property); + if (!prop) + return (BadAlloc); + add = TRUE; + } + else if (prop->immutable && !immutable) + return (BadAccess); /* * ranges must have even number of values */ if (range && (num_values & 1)) - return BadMatch; + return BadMatch; - new_values = xalloc (num_values * sizeof (INT32)); + new_values = xalloc(num_values * sizeof(INT32)); if (!new_values && num_values) - return BadAlloc; + return BadAlloc; if (num_values) - memcpy (new_values, values, num_values * sizeof (INT32)); + memcpy(new_values, values, num_values * sizeof(INT32)); /* * Property moving from pending to non-pending * loses any pending values */ - if (prop->is_pending && !pending) - { - if (prop->pending.data) - xfree (prop->pending.data); - RRInitOutputPropertyValue (&prop->pending); + if (prop->is_pending && !pending) { + if (prop->pending.data) + xfree(prop->pending.data); + RRInitOutputPropertyValue(&prop->pending); } prop->is_pending = pending; @@ -355,89 +346,88 @@ RRConfigureOutputProperty (RROutputPtr output, Atom property, prop->immutable = immutable; prop->num_valid = num_values; if (prop->valid_values) - xfree (prop->valid_values); + xfree(prop->valid_values); prop->valid_values = new_values; if (add) { - prop->next = output->properties; - output->properties = prop; + prop->next = output->properties; + output->properties = prop; } return Success; } int -ProcRRListOutputProperties (ClientPtr client) +ProcRRListOutputProperties(ClientPtr client) { REQUEST(xRRListOutputPropertiesReq); - Atom *pAtoms = NULL, *temppAtoms; - xRRListOutputPropertiesReply rep; - int numProps = 0; - RROutputPtr output; - RRPropertyPtr prop; + Atom *pAtoms = NULL, *temppAtoms; + xRRListOutputPropertiesReply rep; + int numProps = 0; + RROutputPtr output; + RRPropertyPtr prop; REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq); - output = LookupOutput (client, stuff->output, DixReadAccess); + output = LookupOutput(client, stuff->output, DixReadAccess); if (!output) return RRErrorBase + BadRROutput; for (prop = output->properties; prop; prop = prop->next) - numProps++; + numProps++; if (numProps) - if(!(pAtoms = (Atom *)xalloc(numProps * sizeof(Atom)))) - return(BadAlloc); + if (!(pAtoms = (Atom *) xalloc(numProps * sizeof(Atom)))) + return (BadAlloc); rep.type = X_Reply; rep.length = (numProps * sizeof(Atom)) >> 2; rep.sequenceNumber = client->sequence; rep.nAtoms = numProps; - if (client->swapped) - { - int n; - swaps (&rep.sequenceNumber, n); - swapl (&rep.length, n); - swaps (&rep.nAtoms, n); + if (client->swapped) { + int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swaps(&rep.nAtoms, n); } temppAtoms = pAtoms; for (prop = output->properties; prop; prop = prop->next) - *temppAtoms++ = prop->propertyName; + *temppAtoms++ = prop->propertyName; - WriteToClient(client, sizeof(xRRListOutputPropertiesReply), (char*)&rep); - if (numProps) - { - client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write; + WriteToClient(client, sizeof(xRRListOutputPropertiesReply), (char *) &rep); + if (numProps) { + client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms); xfree(pAtoms); } - return(client->noClientException); + return (client->noClientException); } int -ProcRRQueryOutputProperty (ClientPtr client) +ProcRRQueryOutputProperty(ClientPtr client) { REQUEST(xRRQueryOutputPropertyReq); - xRRQueryOutputPropertyReply rep; - RROutputPtr output; - RRPropertyPtr prop; + xRRQueryOutputPropertyReply rep; + RROutputPtr output; + RRPropertyPtr prop; char *extra; REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq); - output = LookupOutput (client, stuff->output, DixReadAccess); + output = LookupOutput(client, stuff->output, DixReadAccess); if (!output) return RRErrorBase + BadRROutput; - prop = RRQueryOutputProperty (output, stuff->property); + prop = RRQueryOutputProperty(output, stuff->property); if (!prop) - return BadName; + return BadName; if (prop->num_valid) { - extra = xalloc(prop->num_valid * sizeof(INT32)); - if (!extra) - return BadAlloc; + extra = xalloc(prop->num_valid * sizeof(INT32)); + if (!extra) + return BadAlloc; } rep.type = X_Reply; rep.length = prop->num_valid; @@ -445,292 +435,279 @@ ProcRRQueryOutputProperty (ClientPtr client) rep.pending = prop->is_pending; rep.range = prop->range; rep.immutable = prop->immutable; - if (client->swapped) - { - int n; - swaps (&rep.sequenceNumber, n); - swapl (&rep.length, n); - } - WriteToClient (client, sizeof (xRRQueryOutputPropertyReply), (char*)&rep); - if (prop->num_valid) - { + if (client->swapped) { + int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + } + WriteToClient(client, sizeof(xRRQueryOutputPropertyReply), (char *) &rep); + if (prop->num_valid) { memcpy(extra, prop->valid_values, prop->num_valid * sizeof(INT32)); - client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write; + client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write; WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32), - extra); + extra); xfree(extra); } - return(client->noClientException); + return (client->noClientException); } int -ProcRRConfigureOutputProperty (ClientPtr client) +ProcRRConfigureOutputProperty(ClientPtr client) { REQUEST(xRRConfigureOutputPropertyReq); - RROutputPtr output; - int num_valid; + RROutputPtr output; + int num_valid; REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq); - output = LookupOutput (client, stuff->output, DixReadAccess); + output = LookupOutput(client, stuff->output, DixReadAccess); if (!output) return RRErrorBase + BadRROutput; - num_valid = stuff->length - (sizeof (xRRConfigureOutputPropertyReq) >> 2); - return RRConfigureOutputProperty (output, stuff->property, - stuff->pending, stuff->range, - FALSE, num_valid, - (INT32 *) (stuff + 1)); + num_valid = stuff->length - (sizeof(xRRConfigureOutputPropertyReq) >> 2); + return RRConfigureOutputProperty(output, stuff->property, + stuff->pending, stuff->range, + FALSE, num_valid, (INT32 *) (stuff + 1)); } int -ProcRRChangeOutputProperty (ClientPtr client) +ProcRRChangeOutputProperty(ClientPtr client) { REQUEST(xRRChangeOutputPropertyReq); - RROutputPtr output; - char format, mode; - unsigned long len; - int sizeInBytes; - int totalSize; - int err; + RROutputPtr output; + char format, mode; + unsigned long len; + int sizeInBytes; + int totalSize; + int err; REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq); UpdateCurrentTime(); format = stuff->format; mode = stuff->mode; if ((mode != PropModeReplace) && (mode != PropModeAppend) && - (mode != PropModePrepend)) - { - client->errorValue = mode; - return BadValue; - } - if ((format != 8) && (format != 16) && (format != 32)) - { - client->errorValue = format; + (mode != PropModePrepend)) { + client->errorValue = mode; + return BadValue; + } + if ((format != 8) && (format != 16) && (format != 32)) { + client->errorValue = format; return BadValue; } len = stuff->nUnits; if (len > ((0xffffffff - sizeof(xChangePropertyReq)) >> 2)) - return BadLength; - sizeInBytes = format>>3; + return BadLength; + sizeInBytes = format >> 3; totalSize = len * sizeInBytes; REQUEST_FIXED_SIZE(xRRChangeOutputPropertyReq, totalSize); - output = LookupOutput (client, stuff->output, DixWriteAccess); + output = LookupOutput(client, stuff->output, DixWriteAccess); if (!output) - return RRErrorBase + BadRROutput; + return RRErrorBase + BadRROutput; - if (!ValidAtom(stuff->property)) - { - client->errorValue = stuff->property; - return(BadAtom); + if (!ValidAtom(stuff->property)) { + client->errorValue = stuff->property; + return (BadAtom); } - if (!ValidAtom(stuff->type)) - { - client->errorValue = stuff->type; - return(BadAtom); + if (!ValidAtom(stuff->type)) { + client->errorValue = stuff->type; + return (BadAtom); } err = RRChangeOutputProperty(output, stuff->property, - stuff->type, (int)format, - (int)mode, len, (void *)&stuff[1], TRUE, TRUE); + stuff->type, (int) format, + (int) mode, len, (void *) &stuff[1], TRUE, + TRUE); if (err != Success) - return err; + return err; else - return client->noClientException; + return client->noClientException; } int -ProcRRDeleteOutputProperty (ClientPtr client) +ProcRRDeleteOutputProperty(ClientPtr client) { REQUEST(xRRDeleteOutputPropertyReq); - RROutputPtr output; + RROutputPtr output; REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq); UpdateCurrentTime(); - output = LookupOutput (client, stuff->output, DixWriteAccess); + output = LookupOutput(client, stuff->output, DixWriteAccess); if (!output) return RRErrorBase + BadRROutput; - if (!ValidAtom(stuff->property)) - { - client->errorValue = stuff->property; - return (BadAtom); + if (!ValidAtom(stuff->property)) { + client->errorValue = stuff->property; + return (BadAtom); } - RRDeleteOutputProperty(output, stuff->property); return client->noClientException; } int -ProcRRGetOutputProperty (ClientPtr client) +ProcRRGetOutputProperty(ClientPtr client) { REQUEST(xRRGetOutputPropertyReq); - RRPropertyPtr prop, *prev; - RRPropertyValuePtr prop_value; - unsigned long n, len, ind; - RROutputPtr output; - xRRGetOutputPropertyReply reply; - char *extra; + RRPropertyPtr prop, *prev; + RRPropertyValuePtr prop_value; + unsigned long n, len, ind; + RROutputPtr output; + xRRGetOutputPropertyReply reply; + char *extra; REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq); if (stuff->delete) - UpdateCurrentTime(); - output = LookupOutput (client, stuff->output, - stuff->delete ? DixWriteAccess : - DixReadAccess); + UpdateCurrentTime(); + output = LookupOutput(client, stuff->output, + stuff->delete ? DixWriteAccess : DixReadAccess); if (!output) - return RRErrorBase + BadRROutput; + return RRErrorBase + BadRROutput; - if (!ValidAtom(stuff->property)) - { - client->errorValue = stuff->property; - return(BadAtom); + if (!ValidAtom(stuff->property)) { + client->errorValue = stuff->property; + return (BadAtom); } - if ((stuff->delete != xTrue) && (stuff->delete != xFalse)) - { - client->errorValue = stuff->delete; - return(BadValue); + if ((stuff->delete != xTrue) && (stuff->delete != xFalse)) { + client->errorValue = stuff->delete; + return (BadValue); } - if ((stuff->type != AnyPropertyType) && !ValidAtom(stuff->type)) - { - client->errorValue = stuff->type; - return(BadAtom); + if ((stuff->type != AnyPropertyType) && !ValidAtom(stuff->type)) { + client->errorValue = stuff->type; + return (BadAtom); } for (prev = &output->properties; (prop = *prev); prev = &prop->next) - if (prop->propertyName == stuff->property) - break; + if (prop->propertyName == stuff->property) + break; reply.type = X_Reply; reply.sequenceNumber = client->sequence; - if (!prop) - { - reply.nItems = 0; - reply.length = 0; - reply.bytesAfter = 0; - reply.propertyType = None; - reply.format = 0; - if (client->swapped) { - int n; - - swaps(&reply.sequenceNumber, n); - swapl(&reply.length, n); - swapl(&reply.propertyType, n); - swapl(&reply.bytesAfter, n); - swapl(&reply.nItems, n); - } - WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply); - return(client->noClientException); + if (!prop) { + reply.nItems = 0; + reply.length = 0; + reply.bytesAfter = 0; + reply.propertyType = None; + reply.format = 0; + if (client->swapped) { + int n; + + swaps(&reply.sequenceNumber, n); + swapl(&reply.length, n); + swapl(&reply.propertyType, n); + swapl(&reply.bytesAfter, n); + swapl(&reply.nItems, n); + } + WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply); + return (client->noClientException); } if (prop->immutable && stuff->delete) - return BadAccess; + return BadAccess; if (stuff->pending && prop->is_pending) - prop_value = &prop->pending; + prop_value = &prop->pending; else - prop_value = &prop->current; + prop_value = &prop->current; /* If the request type and actual type don't match. Return the - property information, but not the data. */ - - if (((stuff->type != prop_value->type) && - (stuff->type != AnyPropertyType)) - ) - { - reply.bytesAfter = prop_value->size; - reply.format = prop_value->format; - reply.length = 0; - reply.nItems = 0; - reply.propertyType = prop_value->type; - if (client->swapped) { - int n; - - swaps(&reply.sequenceNumber, n); - swapl(&reply.length, n); - swapl(&reply.propertyType, n); - swapl(&reply.bytesAfter, n); - swapl(&reply.nItems, n); - } - WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply); - return(client->noClientException); + property information, but not the data. */ + + if (((stuff->type != prop_value->type) && (stuff->type != AnyPropertyType)) + ) { + reply.bytesAfter = prop_value->size; + reply.format = prop_value->format; + reply.length = 0; + reply.nItems = 0; + reply.propertyType = prop_value->type; + if (client->swapped) { + int n; + + swaps(&reply.sequenceNumber, n); + swapl(&reply.length, n); + swapl(&reply.propertyType, n); + swapl(&reply.bytesAfter, n); + swapl(&reply.nItems, n); + } + WriteToClient(client, sizeof(xRRGetOutputPropertyReply), &reply); + return (client->noClientException); } /* * Return type, format, value to client */ - n = (prop_value->format/8) * prop_value->size; /* size (bytes) of prop */ + n = (prop_value->format / 8) * prop_value->size; /* size (bytes) of prop */ ind = stuff->longOffset << 2; - /* If longOffset is invalid such that it causes "len" to - be negative, it's a value error. */ + /* If longOffset is invalid such that it causes "len" to + be negative, it's a value error. */ - if (n < ind) - { - client->errorValue = stuff->longOffset; - return BadValue; + if (n < ind) { + client->errorValue = stuff->longOffset; + return BadValue; } len = min(n - ind, 4 * stuff->longLength); if (len) { - extra = xalloc(len); - if (!extra) - return BadAlloc; + extra = xalloc(len); + if (!extra) + return BadAlloc; } reply.bytesAfter = n - (ind + len); reply.format = prop_value->format; reply.length = (len + 3) >> 2; if (prop_value->format) - reply.nItems = len / (prop_value->format / 8); + reply.nItems = len / (prop_value->format / 8); else - reply.nItems = 0; + reply.nItems = 0; reply.propertyType = prop_value->type; - if (stuff->delete && (reply.bytesAfter == 0)) - { - xRROutputPropertyNotifyEvent event; - - event.type = RREventBase + RRNotify; - event.subCode = RRNotify_OutputProperty; - event.output = output->id; - event.state = PropertyDelete; - event.atom = prop->propertyName; - event.timestamp = currentTime.milliseconds; - RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask); + if (stuff->delete && (reply.bytesAfter == 0)) { + xRROutputPropertyNotifyEvent event; + + event.type = RREventBase + RRNotify; + event.subCode = RRNotify_OutputProperty; + event.output = output->id; + event.state = PropertyDelete; + event.atom = prop->propertyName; + event.timestamp = currentTime.milliseconds; + RRDeliverEvent(output->pScreen, (xEvent *) &event, + RROutputPropertyNotifyMask); } if (client->swapped) { - int n; + int n; - swaps(&reply.sequenceNumber, n); - swapl(&reply.length, n); - swapl(&reply.propertyType, n); - swapl(&reply.bytesAfter, n); - swapl(&reply.nItems, n); + swaps(&reply.sequenceNumber, n); + swapl(&reply.length, n); + swapl(&reply.propertyType, n); + swapl(&reply.bytesAfter, n); + swapl(&reply.nItems, n); } WriteToClient(client, sizeof(xGenericReply), &reply); - if (len) - { - memcpy(extra, (char *)prop_value->data + ind, len); - switch (reply.format) { - case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break; - case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break; - default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break; - } - WriteSwappedDataToClient(client, len, - extra); - xfree(extra); - } - - if (stuff->delete && (reply.bytesAfter == 0)) - { /* delete the Property */ - *prev = prop->next; - RRDestroyOutputProperty (prop); - } - return(client->noClientException); -} + if (len) { + memcpy(extra, (char *) prop_value->data + ind, len); + switch (reply.format) { + case 32: + client->pSwapReplyFunc = (ReplySwapPtr) CopySwap32Write; + break; + case 16: + client->pSwapReplyFunc = (ReplySwapPtr) CopySwap16Write; + break; + default: + client->pSwapReplyFunc = (ReplySwapPtr) WriteToClient; + break; + } + WriteSwappedDataToClient(client, len, extra); + xfree(extra); + } + if (stuff->delete && (reply.bytesAfter == 0)) { /* delete the Property */ + *prev = prop->next; + RRDestroyOutputProperty(prop); + } + return (client->noClientException); +} diff --git a/nx-X11/programs/Xserver/randr/rrscreen.c b/nx-X11/programs/Xserver/randr/rrscreen.c index a13b01dcb..458416c1f 100644 --- a/nx-X11/programs/Xserver/randr/rrscreen.c +++ b/nx-X11/programs/Xserver/randr/rrscreen.c @@ -39,49 +39,46 @@ #include "randrstr.h" -extern char *ConnectionInfo; +extern char *ConnectionInfo; -static int padlength[4] = {0, 3, 2, 1}; +static int padlength[4] = { 0, 3, 2, 1 }; static CARD16 -RR10CurrentSizeID (ScreenPtr pScreen); + RR10CurrentSizeID(ScreenPtr pScreen); /* * Edit connection information block so that new clients * see the current screen size on connect */ static void -RREditConnectionInfo (ScreenPtr pScreen) +RREditConnectionInfo(ScreenPtr pScreen) { - xConnSetup *connSetup; - char *vendor; - xPixmapFormat *formats; - xWindowRoot *root; - xDepth *depth; - xVisualType *visual; - int screen = 0; - int d; + xConnSetup *connSetup; + char *vendor; + xPixmapFormat *formats; + xWindowRoot *root; + xDepth *depth; + xVisualType *visual; + int screen = 0; + int d; connSetup = (xConnSetup *) ConnectionInfo; - vendor = (char *) connSetup + sizeof (xConnSetup); + vendor = (char *) connSetup + sizeof(xConnSetup); formats = (xPixmapFormat *) ((char *) vendor + - connSetup->nbytesVendor + - padlength[connSetup->nbytesVendor & 3]); + connSetup->nbytesVendor + + padlength[connSetup->nbytesVendor & 3]); root = (xWindowRoot *) ((char *) formats + - sizeof (xPixmapFormat) * screenInfo.numPixmapFormats); - while (screen != pScreen->myNum) - { - depth = (xDepth *) ((char *) root + - sizeof (xWindowRoot)); - for (d = 0; d < root->nDepths; d++) - { - visual = (xVisualType *) ((char *) depth + - sizeof (xDepth)); - depth = (xDepth *) ((char *) visual + - depth->nVisuals * sizeof (xVisualType)); - } - root = (xWindowRoot *) ((char *) depth); - screen++; + sizeof(xPixmapFormat) * + screenInfo.numPixmapFormats); + while (screen != pScreen->myNum) { + depth = (xDepth *) ((char *) root + sizeof(xWindowRoot)); + for (d = 0; d < root->nDepths; d++) { + visual = (xVisualType *) ((char *) depth + sizeof(xDepth)); + depth = (xDepth *) ((char *) visual + + depth->nVisuals * sizeof(xVisualType)); + } + root = (xWindowRoot *) ((char *) depth); + screen++; } root->pixWidth = pScreen->width; root->pixHeight = pScreen->height; @@ -90,10 +87,10 @@ RREditConnectionInfo (ScreenPtr pScreen) } void -RRSendConfigNotify (ScreenPtr pScreen) +RRSendConfigNotify(ScreenPtr pScreen) { - WindowPtr pWin = WindowTable[pScreen->myNum]; - xEvent event; + WindowPtr pWin = WindowTable[pScreen->myNum]; + xEvent event; event.u.u.type = ConfigureNotify; event.u.configureNotify.window = pWin->drawable.id; @@ -105,48 +102,49 @@ RRSendConfigNotify (ScreenPtr pScreen) event.u.configureNotify.width = pWin->drawable.width; event.u.configureNotify.height = pWin->drawable.height; - event.u.configureNotify.borderWidth = wBorderWidth (pWin); + event.u.configureNotify.borderWidth = wBorderWidth(pWin); event.u.configureNotify.override = pWin->overrideRedirect; DeliverEvents(pWin, &event, 1, NullWindow); } void -RRDeliverScreenEvent (ClientPtr client, WindowPtr pWin, ScreenPtr pScreen) +RRDeliverScreenEvent(ClientPtr client, WindowPtr pWin, ScreenPtr pScreen) { - rrScrPriv (pScreen); - xRRScreenChangeNotifyEvent se; - RRCrtcPtr crtc = pScrPriv->numCrtcs ? pScrPriv->crtcs[0] : NULL; - WindowPtr pRoot = WindowTable[pScreen->myNum]; + rrScrPriv(pScreen); + xRRScreenChangeNotifyEvent se; + RRCrtcPtr crtc = pScrPriv->numCrtcs ? pScrPriv->crtcs[0] : NULL; + WindowPtr pRoot = WindowTable[pScreen->myNum]; se.type = RRScreenChangeNotify + RREventBase; se.rotation = (CARD8) (crtc ? crtc->rotation : RR_Rotate_0); se.timestamp = pScrPriv->lastSetTime.milliseconds; se.sequenceNumber = client->sequence; se.configTimestamp = pScrPriv->lastConfigTime.milliseconds; - se.root = pRoot->drawable.id; + se.root = pRoot->drawable.id; se.window = pWin->drawable.id; #ifdef RENDER - se.subpixelOrder = PictureGetSubpixelOrder (pScreen); + se.subpixelOrder = PictureGetSubpixelOrder(pScreen); #else se.subpixelOrder = SubPixelUnknown; #endif se.sequenceNumber = client->sequence; - se.sizeID = RR10CurrentSizeID (pScreen); + se.sizeID = RR10CurrentSizeID(pScreen); if (se.rotation & (RR_Rotate_90 | RR_Rotate_270)) { - se.widthInPixels = pScreen->height; - se.heightInPixels = pScreen->width; - se.widthInMillimeters = pScreen->mmHeight; - se.heightInMillimeters = pScreen->mmWidth; - } else { - se.widthInPixels = pScreen->width; - se.heightInPixels = pScreen->height; - se.widthInMillimeters = pScreen->mmWidth; - se.heightInMillimeters = pScreen->mmHeight; + se.widthInPixels = pScreen->height; + se.heightInPixels = pScreen->width; + se.widthInMillimeters = pScreen->mmHeight; + se.heightInMillimeters = pScreen->mmWidth; + } + else { + se.widthInPixels = pScreen->width; + se.heightInPixels = pScreen->height; + se.widthInMillimeters = pScreen->mmWidth; + se.heightInMillimeters = pScreen->mmHeight; } - WriteEventsToClient (client, 1, (xEvent *) &se); + WriteEventsToClient(client, 1, (xEvent *) &se); } /* @@ -155,7 +153,7 @@ RRDeliverScreenEvent (ClientPtr client, WindowPtr pWin, ScreenPtr pScreen) * the size of the screen */ void -RRScreenSizeNotify (ScreenPtr pScreen) +RRScreenSizeNotify(ScreenPtr pScreen) { rrScrPriv(pScreen); /* @@ -163,10 +161,10 @@ RRScreenSizeNotify (ScreenPtr pScreen) * pixel size */ if (pScrPriv->width == pScreen->width && - pScrPriv->height == pScreen->height && - pScrPriv->mmWidth == pScreen->mmWidth && - pScrPriv->mmHeight == pScreen->mmHeight) - return; + pScrPriv->height == pScreen->height && + pScrPriv->mmWidth == pScreen->mmWidth && + pScrPriv->mmHeight == pScreen->mmHeight) + return; pScrPriv->width = pScreen->width; pScrPriv->height = pScreen->height; @@ -175,41 +173,35 @@ RRScreenSizeNotify (ScreenPtr pScreen) pScrPriv->changed = TRUE; /* pScrPriv->sizeChanged = TRUE; */ - RRTellChanged (pScreen); - RRSendConfigNotify (pScreen); - RREditConnectionInfo (pScreen); + RRTellChanged(pScreen); + RRSendConfigNotify(pScreen); + RREditConnectionInfo(pScreen); - RRPointerScreenConfigured (pScreen); + RRPointerScreenConfigured(pScreen); /* * Fix pointer bounds and location */ - ScreenRestructured (pScreen); + ScreenRestructured(pScreen); } /* * Request that the screen be resized */ Bool -RRScreenSizeSet (ScreenPtr pScreen, - CARD16 width, - CARD16 height, - CARD32 mmWidth, - CARD32 mmHeight) +RRScreenSizeSet(ScreenPtr pScreen, + CARD16 width, CARD16 height, CARD32 mmWidth, CARD32 mmHeight) { rrScrPriv(pScreen); #if RANDR_12_INTERFACE - if (pScrPriv->rrScreenSetSize) - { - return (*pScrPriv->rrScreenSetSize) (pScreen, - width, height, - mmWidth, mmHeight); + if (pScrPriv->rrScreenSetSize) { + return (*pScrPriv->rrScreenSetSize) (pScreen, + width, height, mmWidth, mmHeight); } #endif #if RANDR_10_INTERFACE - if (pScrPriv->rrSetConfig) - { - return TRUE; /* can't set size separately */ + if (pScrPriv->rrSetConfig) { + return TRUE; /* can't set size separately */ } #endif return FALSE; @@ -219,24 +211,24 @@ RRScreenSizeSet (ScreenPtr pScreen, * Retrieve valid screen size range */ int -ProcRRGetScreenSizeRange (ClientPtr client) +ProcRRGetScreenSizeRange(ClientPtr client) { REQUEST(xRRGetScreenSizeRangeReq); - xRRGetScreenSizeRangeReply rep; - WindowPtr pWin; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - int rc; + xRRGetScreenSizeRangeReply rep; + WindowPtr pWin; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + int rc; REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pWin->drawable.pScreen; pScrPriv = rrGetScrPriv(pScreen); @@ -246,291 +238,272 @@ ProcRRGetScreenSizeRange (ClientPtr client) rep.sequenceNumber = client->sequence; rep.length = 0; - if (pScrPriv) - { - if (!RRGetInfo (pScreen)) - return BadAlloc; - rep.minWidth = pScrPriv->minWidth; - rep.minHeight = pScrPriv->minHeight; - rep.maxWidth = pScrPriv->maxWidth; - rep.maxHeight = pScrPriv->maxHeight; + if (pScrPriv) { + if (!RRGetInfo(pScreen)) + return BadAlloc; + rep.minWidth = pScrPriv->minWidth; + rep.minHeight = pScrPriv->minHeight; + rep.maxWidth = pScrPriv->maxWidth; + rep.maxHeight = pScrPriv->maxHeight; } - else - { - rep.maxWidth = rep.minWidth = pScreen->width; - rep.maxHeight = rep.minHeight = pScreen->height; + else { + rep.maxWidth = rep.minWidth = pScreen->width; + rep.maxHeight = rep.minHeight = pScreen->height; } - if (client->swapped) - { - int n; - - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swaps(&rep.minWidth, n); - swaps(&rep.minHeight, n); - swaps(&rep.maxWidth, n); - swaps(&rep.maxHeight, n); + if (client->swapped) { + int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swaps(&rep.minWidth, n); + swaps(&rep.minHeight, n); + swaps(&rep.maxWidth, n); + swaps(&rep.maxHeight, n); } - WriteToClient(client, sizeof(xRRGetScreenSizeRangeReply), (char *)&rep); + WriteToClient(client, sizeof(xRRGetScreenSizeRangeReply), (char *) &rep); return (client->noClientException); } int -ProcRRSetScreenSize (ClientPtr client) +ProcRRSetScreenSize(ClientPtr client) { REQUEST(xRRSetScreenSizeReq); - WindowPtr pWin; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - int i, rc; + WindowPtr pWin; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + int i, rc; REQUEST_SIZE_MATCH(xRRSetScreenSizeReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pWin->drawable.pScreen; pScrPriv = rrGetScrPriv(pScreen); - if (stuff->width < pScrPriv->minWidth || pScrPriv->maxWidth < stuff->width) - { - client->errorValue = stuff->width; - return BadValue; + if (stuff->width < pScrPriv->minWidth || pScrPriv->maxWidth < stuff->width) { + client->errorValue = stuff->width; + return BadValue; } if (stuff->height < pScrPriv->minHeight || - pScrPriv->maxHeight < stuff->height) - { - client->errorValue = stuff->height; - return BadValue; - } - for (i = 0; i < pScrPriv->numCrtcs; i++) - { - RRCrtcPtr crtc = pScrPriv->crtcs[i]; - RRModePtr mode = crtc->mode; - if (mode) - { - int source_width = mode->mode.width; - int source_height = mode->mode.height; - Rotation rotation = crtc->rotation; - - if (rotation == RR_Rotate_90 || rotation == RR_Rotate_270) - { - source_width = mode->mode.height; - source_height = mode->mode.width; - } - - if (crtc->x + source_width > stuff->width || - crtc->y + source_height > stuff->height) - return BadMatch; - } - } - if (stuff->widthInMillimeters == 0 || stuff->heightInMillimeters == 0) - { - client->errorValue = 0; - return BadValue; - } - if (!RRScreenSizeSet (pScreen, - stuff->width, stuff->height, - stuff->widthInMillimeters, - stuff->heightInMillimeters)) - { - return BadMatch; + pScrPriv->maxHeight < stuff->height) { + client->errorValue = stuff->height; + return BadValue; + } + for (i = 0; i < pScrPriv->numCrtcs; i++) { + RRCrtcPtr crtc = pScrPriv->crtcs[i]; + RRModePtr mode = crtc->mode; + + if (mode) { + int source_width = mode->mode.width; + int source_height = mode->mode.height; + Rotation rotation = crtc->rotation; + + if (rotation == RR_Rotate_90 || rotation == RR_Rotate_270) { + source_width = mode->mode.height; + source_height = mode->mode.width; + } + + if (crtc->x + source_width > stuff->width || + crtc->y + source_height > stuff->height) + return BadMatch; + } + } + if (stuff->widthInMillimeters == 0 || stuff->heightInMillimeters == 0) { + client->errorValue = 0; + return BadValue; + } + if (!RRScreenSizeSet(pScreen, + stuff->width, stuff->height, + stuff->widthInMillimeters, + stuff->heightInMillimeters)) { + return BadMatch; } return Success; } int -ProcRRGetScreenResources (ClientPtr client) +ProcRRGetScreenResources(ClientPtr client) { REQUEST(xRRGetScreenResourcesReq); - xRRGetScreenResourcesReply rep; - WindowPtr pWin; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - CARD8 *extra; - unsigned long extraLen; - int i, n, rc; - RRCrtc *crtcs; - RROutput *outputs; - xRRModeInfo *modeinfos; - CARD8 *names; + xRRGetScreenResourcesReply rep; + WindowPtr pWin; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + CARD8 *extra; + unsigned long extraLen; + int i, n, rc; + RRCrtc *crtcs; + RROutput *outputs; + xRRModeInfo *modeinfos; + CARD8 *names; REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pWin->drawable.pScreen; pScrPriv = rrGetScrPriv(pScreen); rep.pad = 0; if (pScrPriv) - if (!RRGetInfo (pScreen)) - return BadAlloc; - - if (!pScrPriv) - { - rep.type = X_Reply; - rep.sequenceNumber = client->sequence; - rep.length = 0; - rep.timestamp = currentTime.milliseconds; - rep.configTimestamp = currentTime.milliseconds; - rep.nCrtcs = 0; - rep.nOutputs = 0; - rep.nModes = 0; - rep.nbytesNames = 0; - extra = NULL; - extraLen = 0; + if (!RRGetInfo(pScreen)) + return BadAlloc; + + if (!pScrPriv) { + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + rep.timestamp = currentTime.milliseconds; + rep.configTimestamp = currentTime.milliseconds; + rep.nCrtcs = 0; + rep.nOutputs = 0; + rep.nModes = 0; + rep.nbytesNames = 0; + extra = NULL; + extraLen = 0; } - else - { - RRModePtr *modes; - int num_modes; - - modes = RRModesForScreen (pScreen, &num_modes); - if (!modes) - return BadAlloc; - - rep.type = X_Reply; - rep.sequenceNumber = client->sequence; - rep.length = 0; - rep.timestamp = pScrPriv->lastSetTime.milliseconds; - rep.configTimestamp = pScrPriv->lastConfigTime.milliseconds; - rep.nCrtcs = pScrPriv->numCrtcs; - rep.nOutputs = pScrPriv->numOutputs; - rep.nModes = num_modes; - rep.nbytesNames = 0; - - for (i = 0; i < num_modes; i++) - rep.nbytesNames += modes[i]->mode.nameLength; - - rep.length = (pScrPriv->numCrtcs + - pScrPriv->numOutputs + - num_modes * (SIZEOF(xRRModeInfo) >> 2) + - ((rep.nbytesNames + 3) >> 2)); - - extraLen = rep.length << 2; - if (extraLen) - { - extra = xalloc (extraLen); - if (!extra) - { - xfree (modes); - return BadAlloc; - } - } - else - extra = NULL; - - crtcs = (RRCrtc *) extra; - outputs = (RROutput *) (crtcs + pScrPriv->numCrtcs); - modeinfos = (xRRModeInfo *) (outputs + pScrPriv->numOutputs); - names = (CARD8 *) (modeinfos + num_modes); - - for (i = 0; i < pScrPriv->numCrtcs; i++) - { - crtcs[i] = pScrPriv->crtcs[i]->id; - if (client->swapped) - swapl (&crtcs[i], n); - } - - for (i = 0; i < pScrPriv->numOutputs; i++) - { - outputs[i] = pScrPriv->outputs[i]->id; - if (client->swapped) - swapl (&outputs[i], n); - } - - for (i = 0; i < num_modes; i++) - { - RRModePtr mode = modes[i]; - modeinfos[i] = mode->mode; - if (client->swapped) - { - swapl (&modeinfos[i].id, n); - swaps (&modeinfos[i].width, n); - swaps (&modeinfos[i].height, n); - swapl (&modeinfos[i].dotClock, n); - swaps (&modeinfos[i].hSyncStart, n); - swaps (&modeinfos[i].hSyncEnd, n); - swaps (&modeinfos[i].hTotal, n); - swaps (&modeinfos[i].hSkew, n); - swaps (&modeinfos[i].vSyncStart, n); - swaps (&modeinfos[i].vSyncEnd, n); - swaps (&modeinfos[i].vTotal, n); - swaps (&modeinfos[i].nameLength, n); - swapl (&modeinfos[i].modeFlags, n); - } - memcpy (names, mode->name, - mode->mode.nameLength); - names += mode->mode.nameLength; - } - xfree (modes); - assert (((((char *) names - (char *) extra) + 3) >> 2) == rep.length); + else { + RRModePtr *modes; + int num_modes; + + modes = RRModesForScreen(pScreen, &num_modes); + if (!modes) + return BadAlloc; + + rep.type = X_Reply; + rep.sequenceNumber = client->sequence; + rep.length = 0; + rep.timestamp = pScrPriv->lastSetTime.milliseconds; + rep.configTimestamp = pScrPriv->lastConfigTime.milliseconds; + rep.nCrtcs = pScrPriv->numCrtcs; + rep.nOutputs = pScrPriv->numOutputs; + rep.nModes = num_modes; + rep.nbytesNames = 0; + + for (i = 0; i < num_modes; i++) + rep.nbytesNames += modes[i]->mode.nameLength; + + rep.length = (pScrPriv->numCrtcs + + pScrPriv->numOutputs + + num_modes * (SIZEOF(xRRModeInfo) >> 2) + + ((rep.nbytesNames + 3) >> 2)); + + extraLen = rep.length << 2; + if (extraLen) { + extra = xalloc(extraLen); + if (!extra) { + xfree(modes); + return BadAlloc; + } + } + else + extra = NULL; + + crtcs = (RRCrtc *) extra; + outputs = (RROutput *) (crtcs + pScrPriv->numCrtcs); + modeinfos = (xRRModeInfo *) (outputs + pScrPriv->numOutputs); + names = (CARD8 *) (modeinfos + num_modes); + + for (i = 0; i < pScrPriv->numCrtcs; i++) { + crtcs[i] = pScrPriv->crtcs[i]->id; + if (client->swapped) + swapl(&crtcs[i], n); + } + + for (i = 0; i < pScrPriv->numOutputs; i++) { + outputs[i] = pScrPriv->outputs[i]->id; + if (client->swapped) + swapl(&outputs[i], n); + } + + for (i = 0; i < num_modes; i++) { + RRModePtr mode = modes[i]; + + modeinfos[i] = mode->mode; + if (client->swapped) { + swapl(&modeinfos[i].id, n); + swaps(&modeinfos[i].width, n); + swaps(&modeinfos[i].height, n); + swapl(&modeinfos[i].dotClock, n); + swaps(&modeinfos[i].hSyncStart, n); + swaps(&modeinfos[i].hSyncEnd, n); + swaps(&modeinfos[i].hTotal, n); + swaps(&modeinfos[i].hSkew, n); + swaps(&modeinfos[i].vSyncStart, n); + swaps(&modeinfos[i].vSyncEnd, n); + swaps(&modeinfos[i].vTotal, n); + swaps(&modeinfos[i].nameLength, n); + swapl(&modeinfos[i].modeFlags, n); + } + memcpy(names, mode->name, mode->mode.nameLength); + names += mode->mode.nameLength; + } + xfree(modes); + assert(((((char *) names - (char *) extra) + 3) >> 2) == rep.length); } if (client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.timestamp, n); - swapl(&rep.configTimestamp, n); - swaps(&rep.nCrtcs, n); - swaps(&rep.nOutputs, n); - swaps(&rep.nModes, n); - swaps(&rep.nbytesNames, n); + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.timestamp, n); + swapl(&rep.configTimestamp, n); + swaps(&rep.nCrtcs, n); + swaps(&rep.nOutputs, n); + swaps(&rep.nModes, n); + swaps(&rep.nbytesNames, n); } - WriteToClient(client, sizeof(xRRGetScreenResourcesReply), (char *)&rep); - if (extraLen) - { - WriteToClient (client, extraLen, (char *) extra); - xfree (extra); + WriteToClient(client, sizeof(xRRGetScreenResourcesReply), (char *) &rep); + if (extraLen) { + WriteToClient(client, extraLen, (char *) extra); + xfree(extra); } return client->noClientException; } typedef struct _RR10Data { RRScreenSizePtr sizes; - int nsize; - int nrefresh; - int size; - CARD16 refresh; + int nsize; + int nrefresh; + int size; + CARD16 refresh; } RR10DataRec, *RR10DataPtr; /* * Convert 1.2 monitor data into 1.0 screen data */ static RR10DataPtr -RR10GetData (ScreenPtr pScreen, RROutputPtr output) +RR10GetData(ScreenPtr pScreen, RROutputPtr output) { - RR10DataPtr data; + RR10DataPtr data; RRScreenSizePtr size; - int nmode = output->numModes + output->numUserModes; - int o, os, l, r; + int nmode = output->numModes + output->numUserModes; + int o, os, l, r; RRScreenRatePtr refresh; - CARD16 vRefresh; - RRModePtr mode; - Bool *used; + CARD16 vRefresh; + RRModePtr mode; + Bool *used; /* Make sure there is plenty of space for any combination */ - data = malloc (sizeof (RR10DataRec) + - sizeof (RRScreenSize) * nmode + - sizeof (RRScreenRate) * nmode + - sizeof (Bool) * nmode); + data = malloc(sizeof(RR10DataRec) + + sizeof(RRScreenSize) * nmode + + sizeof(RRScreenRate) * nmode + sizeof(Bool) * nmode); if (!data) - return NULL; + return NULL; size = (RRScreenSizePtr) (data + 1); refresh = (RRScreenRatePtr) (size + nmode); used = (Bool *) (refresh + nmode); - memset (used, '\0', sizeof (Bool) * nmode); + memset(used, '\0', sizeof(Bool) * nmode); data->sizes = size; data->nsize = 0; data->nrefresh = 0; @@ -540,269 +513,254 @@ RR10GetData (ScreenPtr pScreen, RROutputPtr output) /* * find modes not yet listed */ - for (o = 0; o < output->numModes + output->numUserModes; o++) - { - if (used[o]) continue; - - if (o < output->numModes) - mode = output->modes[o]; - else - mode = output->userModes[o - output->numModes]; - - l = data->nsize; - size[l].id = data->nsize; - size[l].width = mode->mode.width; - size[l].height = mode->mode.height; - if (output->mmWidth && output->mmHeight) { - size[l].mmWidth = output->mmWidth; - size[l].mmHeight = output->mmHeight; - } else { - size[l].mmWidth = pScreen->mmWidth; - size[l].mmHeight = pScreen->mmHeight; - } - size[l].nRates = 0; - size[l].pRates = &refresh[data->nrefresh]; - data->nsize++; - - /* - * Find all modes with matching size - */ - for (os = o; os < output->numModes + output->numUserModes; os++) - { - if (os < output->numModes) - mode = output->modes[os]; - else - mode = output->userModes[os - output->numModes]; - if (mode->mode.width == size[l].width && - mode->mode.height == size[l].height) - { - vRefresh = RRVerticalRefresh (&mode->mode); - used[os] = TRUE; - - for (r = 0; r < size[l].nRates; r++) - if (vRefresh == size[l].pRates[r].rate) - break; - if (r == size[l].nRates) - { - size[l].pRates[r].rate = vRefresh; - size[l].pRates[r].mode = mode; - size[l].nRates++; - data->nrefresh++; - } - if (mode == output->crtc->mode) - { - data->size = l; - data->refresh = vRefresh; - } - } - } + for (o = 0; o < output->numModes + output->numUserModes; o++) { + if (used[o]) + continue; + + if (o < output->numModes) + mode = output->modes[o]; + else + mode = output->userModes[o - output->numModes]; + + l = data->nsize; + size[l].id = data->nsize; + size[l].width = mode->mode.width; + size[l].height = mode->mode.height; + if (output->mmWidth && output->mmHeight) { + size[l].mmWidth = output->mmWidth; + size[l].mmHeight = output->mmHeight; + } + else { + size[l].mmWidth = pScreen->mmWidth; + size[l].mmHeight = pScreen->mmHeight; + } + size[l].nRates = 0; + size[l].pRates = &refresh[data->nrefresh]; + data->nsize++; + + /* + * Find all modes with matching size + */ + for (os = o; os < output->numModes + output->numUserModes; os++) { + if (os < output->numModes) + mode = output->modes[os]; + else + mode = output->userModes[os - output->numModes]; + if (mode->mode.width == size[l].width && + mode->mode.height == size[l].height) { + vRefresh = RRVerticalRefresh(&mode->mode); + used[os] = TRUE; + + for (r = 0; r < size[l].nRates; r++) + if (vRefresh == size[l].pRates[r].rate) + break; + if (r == size[l].nRates) { + size[l].pRates[r].rate = vRefresh; + size[l].pRates[r].mode = mode; + size[l].nRates++; + data->nrefresh++; + } + if (mode == output->crtc->mode) { + data->size = l; + data->refresh = vRefresh; + } + } + } } return data; } int -ProcRRGetScreenInfo (ClientPtr client) +ProcRRGetScreenInfo(ClientPtr client) { REQUEST(xRRGetScreenInfoReq); - xRRGetScreenInfoReply rep; - WindowPtr pWin; - int n, rc; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - CARD8 *extra; - unsigned long extraLen; - RROutputPtr output; + xRRGetScreenInfoReply rep; + WindowPtr pWin; + int n, rc; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + CARD8 *extra; + unsigned long extraLen; + RROutputPtr output; REQUEST_SIZE_MATCH(xRRGetScreenInfoReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixReadAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pWin->drawable.pScreen; pScrPriv = rrGetScrPriv(pScreen); rep.pad = 0; if (pScrPriv) - if (!RRGetInfo (pScreen)) - return BadAlloc; - - output = RRFirstOutput (pScreen); - - if (!pScrPriv || !output) - { - rep.type = X_Reply; - rep.setOfRotations = RR_Rotate_0;; - rep.sequenceNumber = client->sequence; - rep.length = 0; - rep.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id; - rep.timestamp = currentTime.milliseconds; - rep.configTimestamp = currentTime.milliseconds; - rep.nSizes = 0; - rep.sizeID = 0; - rep.rotation = RR_Rotate_0; - rep.rate = 0; - rep.nrateEnts = 0; - extra = 0; - extraLen = 0; + if (!RRGetInfo(pScreen)) + return BadAlloc; + + output = RRFirstOutput(pScreen); + + if (!pScrPriv || !output) { + rep.type = X_Reply; + rep.setOfRotations = RR_Rotate_0;; + rep.sequenceNumber = client->sequence; + rep.length = 0; + rep.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id; + rep.timestamp = currentTime.milliseconds; + rep.configTimestamp = currentTime.milliseconds; + rep.nSizes = 0; + rep.sizeID = 0; + rep.rotation = RR_Rotate_0; + rep.rate = 0; + rep.nrateEnts = 0; + extra = 0; + extraLen = 0; } - else - { - int i, j; - xScreenSizes *size; - CARD16 *rates; - CARD8 *data8; - Bool has_rate = RRClientKnowsRates (client); - RR10DataPtr pData; - RRScreenSizePtr pSize; - - pData = RR10GetData (pScreen, output); - if (!pData) - return BadAlloc; - - rep.type = X_Reply; - rep.setOfRotations = output->crtc->rotations; - rep.sequenceNumber = client->sequence; - rep.length = 0; - rep.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id; - rep.timestamp = pScrPriv->lastSetTime.milliseconds; - rep.configTimestamp = pScrPriv->lastConfigTime.milliseconds; - rep.rotation = output->crtc->rotation; - rep.nSizes = pData->nsize; + else { + int i, j; + xScreenSizes *size; + CARD16 *rates; + CARD8 *data8; + Bool has_rate = RRClientKnowsRates(client); + RR10DataPtr pData; + RRScreenSizePtr pSize; + + pData = RR10GetData(pScreen, output); + if (!pData) + return BadAlloc; + + rep.type = X_Reply; + rep.setOfRotations = output->crtc->rotations; + rep.sequenceNumber = client->sequence; + rep.length = 0; + rep.root = WindowTable[pWin->drawable.pScreen->myNum]->drawable.id; + rep.timestamp = pScrPriv->lastSetTime.milliseconds; + rep.configTimestamp = pScrPriv->lastConfigTime.milliseconds; + rep.rotation = output->crtc->rotation; + rep.nSizes = pData->nsize; rep.nrateEnts = pData->nrefresh + pData->nsize; - rep.sizeID = pData->size; - rep.rate = pData->refresh; - - extraLen = rep.nSizes * sizeof (xScreenSizes); - if (has_rate) - extraLen += rep.nrateEnts * sizeof (CARD16); - - if (extraLen) - { - extra = (CARD8 *) xalloc (extraLen); - if (!extra) - { - xfree (pData); - return BadAlloc; - } - } - else - extra = NULL; - - /* - * First comes the size information - */ - size = (xScreenSizes *) extra; - rates = (CARD16 *) (size + rep.nSizes); - for (i = 0; i < pData->nsize; i++) - { - pSize = &pData->sizes[i]; - size->widthInPixels = pSize->width; - size->heightInPixels = pSize->height; - size->widthInMillimeters = pSize->mmWidth; - size->heightInMillimeters = pSize->mmHeight; - if (client->swapped) - { - swaps (&size->widthInPixels, n); - swaps (&size->heightInPixels, n); - swaps (&size->widthInMillimeters, n); - swaps (&size->heightInMillimeters, n); - } - size++; - if (has_rate) - { - *rates = pSize->nRates; - if (client->swapped) - { - swaps (rates, n); - } - rates++; - for (j = 0; j < pSize->nRates; j++) - { - *rates = pSize->pRates[j].rate; - if (client->swapped) - { - swaps (rates, n); - } - rates++; - } - } - } - xfree (pData); - - data8 = (CARD8 *) rates; - - if (data8 - (CARD8 *) extra != extraLen) - FatalError ("RRGetScreenInfo bad extra len %ld != %ld\n", - (unsigned long)(data8 - (CARD8 *) extra), extraLen); - rep.length = (extraLen + 3) >> 2; + rep.sizeID = pData->size; + rep.rate = pData->refresh; + + extraLen = rep.nSizes * sizeof(xScreenSizes); + if (has_rate) + extraLen += rep.nrateEnts * sizeof(CARD16); + + if (extraLen) { + extra = (CARD8 *) xalloc(extraLen); + if (!extra) { + xfree(pData); + return BadAlloc; + } + } + else + extra = NULL; + + /* + * First comes the size information + */ + size = (xScreenSizes *) extra; + rates = (CARD16 *) (size + rep.nSizes); + for (i = 0; i < pData->nsize; i++) { + pSize = &pData->sizes[i]; + size->widthInPixels = pSize->width; + size->heightInPixels = pSize->height; + size->widthInMillimeters = pSize->mmWidth; + size->heightInMillimeters = pSize->mmHeight; + if (client->swapped) { + swaps(&size->widthInPixels, n); + swaps(&size->heightInPixels, n); + swaps(&size->widthInMillimeters, n); + swaps(&size->heightInMillimeters, n); + } + size++; + if (has_rate) { + *rates = pSize->nRates; + if (client->swapped) { + swaps(rates, n); + } + rates++; + for (j = 0; j < pSize->nRates; j++) { + *rates = pSize->pRates[j].rate; + if (client->swapped) { + swaps(rates, n); + } + rates++; + } + } + } + xfree(pData); + + data8 = (CARD8 *) rates; + + if (data8 - (CARD8 *) extra != extraLen) + FatalError("RRGetScreenInfo bad extra len %ld != %ld\n", + (unsigned long) (data8 - (CARD8 *) extra), extraLen); + rep.length = (extraLen + 3) >> 2; } if (client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.timestamp, n); + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.timestamp, n); swapl(&rep.configTimestamp, n); - swaps(&rep.rotation, n); - swaps(&rep.nSizes, n); - swaps(&rep.sizeID, n); - swaps(&rep.rate, n); - swaps(&rep.nrateEnts, n); + swaps(&rep.rotation, n); + swaps(&rep.nSizes, n); + swaps(&rep.sizeID, n); + swaps(&rep.rate, n); + swaps(&rep.nrateEnts, n); } - WriteToClient(client, sizeof(xRRGetScreenInfoReply), (char *)&rep); - if (extraLen) - { - WriteToClient (client, extraLen, (char *) extra); - xfree (extra); + WriteToClient(client, sizeof(xRRGetScreenInfoReply), (char *) &rep); + if (extraLen) { + WriteToClient(client, extraLen, (char *) extra); + xfree(extra); } return (client->noClientException); } int -ProcRRSetScreenConfig (ClientPtr client) +ProcRRSetScreenConfig(ClientPtr client) { REQUEST(xRRSetScreenConfigReq); xRRSetScreenConfigReply rep; - DrawablePtr pDraw; - int n, rc; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - TimeStamp time; - int i; - Rotation rotation; - int rate; - Bool has_rate; - RROutputPtr output; - RRCrtcPtr crtc; - RRModePtr mode; - RR10DataPtr pData = NULL; - RRScreenSizePtr pSize; - int width, height; - - UpdateCurrentTime (); - - if (RRClientKnowsRates (client)) - { - REQUEST_SIZE_MATCH (xRRSetScreenConfigReq); - has_rate = TRUE; + DrawablePtr pDraw; + int n, rc; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + TimeStamp time; + int i; + Rotation rotation; + int rate; + Bool has_rate; + RROutputPtr output; + RRCrtcPtr crtc; + RRModePtr mode; + RR10DataPtr pData = NULL; + RRScreenSizePtr pSize; + int width, height; + + UpdateCurrentTime(); + + if (RRClientKnowsRates(client)) { + REQUEST_SIZE_MATCH(xRRSetScreenConfigReq); + has_rate = TRUE; } - else - { - REQUEST_SIZE_MATCH (xRR1_0SetScreenConfigReq); - has_rate = FALSE; + else { + REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq); + has_rate = FALSE; } - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupDrawable(&pDraw, stuff->drawable, client, 0, DixWriteAccess); - #else - pDraw = SecurityLookupDrawable(stuff->drawable, client, SecurityWriteAccess); +#else + pDraw = + SecurityLookupDrawable(stuff->drawable, client, SecurityWriteAccess); rc = pDraw ? Success : BadDrawable; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pDraw->pScreen; @@ -810,21 +768,19 @@ ProcRRSetScreenConfig (ClientPtr client) time = ClientTimeToServerTime(stuff->timestamp); - if (!pScrPriv) - { - time = currentTime; - rep.status = RRSetConfigFailed; - goto sendReply; + if (!pScrPriv) { + time = currentTime; + rep.status = RRSetConfigFailed; + goto sendReply; } - if (!RRGetInfo (pScreen)) - return BadAlloc; - - output = RRFirstOutput (pScreen); - if (!output) - { - time = currentTime; - rep.status = RRSetConfigFailed; - goto sendReply; + if (!RRGetInfo(pScreen)) + return BadAlloc; + + output = RRFirstOutput(pScreen); + if (!output) { + time = currentTime; + rep.status = RRSetConfigFailed; + goto sendReply; } crtc = output->crtc; @@ -838,24 +794,22 @@ ProcRRSetScreenConfig (ClientPtr client) * timestamp, so using CompareTimeStamps here would cause randr to suddenly * stop working after several hours have passed (freedesktop bug #6502). */ - if (stuff->configTimestamp != pScrPriv->lastConfigTime.milliseconds) - { - rep.status = RRSetConfigInvalidConfigTime; - goto sendReply; + if (stuff->configTimestamp != pScrPriv->lastConfigTime.milliseconds) { + rep.status = RRSetConfigInvalidConfigTime; + goto sendReply; } - pData = RR10GetData (pScreen, output); + pData = RR10GetData(pScreen, output); if (!pData) - return BadAlloc; - - if (stuff->sizeID >= pData->nsize) - { - /* - * Invalid size ID - */ - client->errorValue = stuff->sizeID; - xfree (pData); - return BadValue; + return BadAlloc; + + if (stuff->sizeID >= pData->nsize) { + /* + * Invalid size ID + */ + client->errorValue = stuff->sizeID; + xfree(pData); + return BadValue; } pSize = &pData->sizes[stuff->sizeID]; @@ -870,63 +824,58 @@ ProcRRSetScreenConfig (ClientPtr client) case RR_Rotate_90: case RR_Rotate_180: case RR_Rotate_270: - break; + break; default: - /* - * Invalid rotation - */ - client->errorValue = stuff->rotation; - xfree (pData); - return BadValue; + /* + * Invalid rotation + */ + client->errorValue = stuff->rotation; + xfree(pData); + return BadValue; } - if ((~crtc->rotations) & rotation) - { - /* - * requested rotation or reflection not supported by screen - */ - client->errorValue = stuff->rotation; - xfree (pData); - return BadMatch; + if ((~crtc->rotations) & rotation) { + /* + * requested rotation or reflection not supported by screen + */ + client->errorValue = stuff->rotation; + xfree(pData); + return BadMatch; } /* * Validate requested refresh */ if (has_rate) - rate = (int) stuff->rate; + rate = (int) stuff->rate; else - rate = 0; - - if (rate) - { - for (i = 0; i < pSize->nRates; i++) - { - if (pSize->pRates[i].rate == rate) - break; - } - if (i == pSize->nRates) - { - /* - * Invalid rate - */ - client->errorValue = rate; - xfree (pData); - return BadValue; - } - mode = pSize->pRates[i].mode; + rate = 0; + + if (rate) { + for (i = 0; i < pSize->nRates; i++) { + if (pSize->pRates[i].rate == rate) + break; + } + if (i == pSize->nRates) { + /* + * Invalid rate + */ + client->errorValue = rate; + xfree(pData); + return BadValue; + } + mode = pSize->pRates[i].mode; } else - mode = pSize->pRates[0].mode; + mode = pSize->pRates[0].mode; /* * Make sure the requested set-time is not older than * the last set-time */ - if (CompareTimeStamps (time, pScrPriv->lastSetTime) < 0) - { - rep.status = RRSetConfigInvalidTime; - goto sendReply; + if (CompareTimeStamps(time, pScrPriv->lastSetTime) < 0) { + rep.status = RRSetConfigInvalidTime; + goto sendReply; } /* @@ -935,61 +884,56 @@ ProcRRSetScreenConfig (ClientPtr client) */ width = mode->mode.width; height = mode->mode.height; - if (rotation & (RR_Rotate_90|RR_Rotate_270)) - { - width = mode->mode.height; - height = mode->mode.width; + if (rotation & (RR_Rotate_90 | RR_Rotate_270)) { + width = mode->mode.height; + height = mode->mode.width; } if (width < pScrPriv->minWidth || pScrPriv->maxWidth < width) { - client->errorValue = width; - xfree (pData); - return BadValue; + client->errorValue = width; + xfree(pData); + return BadValue; } if (height < pScrPriv->minHeight || pScrPriv->maxHeight < height) { - client->errorValue = height; - xfree (pData); - return BadValue; - } - - if (width != pScreen->width || height != pScreen->height) - { - int c; - - for (c = 0; c < pScrPriv->numCrtcs; c++) - { - if (!RRCrtcSet (pScrPriv->crtcs[c], NULL, 0, 0, RR_Rotate_0, - 0, NULL)) - { - rep.status = RRSetConfigFailed; - /* XXX recover from failure */ - goto sendReply; - } - } - if (!RRScreenSizeSet (pScreen, width, height, - pScreen->mmWidth, pScreen->mmHeight)) - { - rep.status = RRSetConfigFailed; - /* XXX recover from failure */ - goto sendReply; - } - } - - if (!RRCrtcSet (crtc, mode, 0, 0, stuff->rotation, 1, &output)) - rep.status = RRSetConfigFailed; + client->errorValue = height; + xfree(pData); + return BadValue; + } + + if (width != pScreen->width || height != pScreen->height) { + int c; + + for (c = 0; c < pScrPriv->numCrtcs; c++) { + if (!RRCrtcSet(pScrPriv->crtcs[c], NULL, 0, 0, RR_Rotate_0, + 0, NULL)) { + rep.status = RRSetConfigFailed; + /* XXX recover from failure */ + goto sendReply; + } + } + if (!RRScreenSizeSet(pScreen, width, height, + pScreen->mmWidth, pScreen->mmHeight)) { + rep.status = RRSetConfigFailed; + /* XXX recover from failure */ + goto sendReply; + } + } + + if (!RRCrtcSet(crtc, mode, 0, 0, stuff->rotation, 1, &output)) + rep.status = RRSetConfigFailed; else { - pScrPriv->lastSetTime = time; - rep.status = RRSetConfigSuccess; + pScrPriv->lastSetTime = time; + rep.status = RRSetConfigSuccess; } /* * XXX Configure other crtcs to mirror as much as possible */ -sendReply: + sendReply: if (pData) - xfree (pData); + xfree(pData); rep.type = X_Reply; /* rep.status has already been filled in */ @@ -1000,40 +944,38 @@ sendReply: rep.newConfigTimestamp = pScrPriv->lastConfigTime.milliseconds; rep.root = WindowTable[pDraw->pScreen->myNum]->drawable.id; - if (client->swapped) - { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.newTimestamp, n); - swapl(&rep.newConfigTimestamp, n); - swapl(&rep.root, n); + if (client->swapped) { + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.newTimestamp, n); + swapl(&rep.newConfigTimestamp, n); + swapl(&rep.root, n); } - WriteToClient(client, sizeof(xRRSetScreenConfigReply), (char *)&rep); + WriteToClient(client, sizeof(xRRSetScreenConfigReply), (char *) &rep); return (client->noClientException); } static CARD16 -RR10CurrentSizeID (ScreenPtr pScreen) +RR10CurrentSizeID(ScreenPtr pScreen) { - CARD16 sizeID = 0xffff; - RROutputPtr output = RRFirstOutput (pScreen); - - if (output) - { - RR10DataPtr data = RR10GetData (pScreen, output); - if (data) - { - int i; - for (i = 0; i < data->nsize; i++) - if (data->sizes[i].width == pScreen->width && - data->sizes[i].height == pScreen->height) - { - sizeID = (CARD16) i; - break; - } - xfree (data); - } + CARD16 sizeID = 0xffff; + RROutputPtr output = RRFirstOutput(pScreen); + + if (output) { + RR10DataPtr data = RR10GetData(pScreen, output); + + if (data) { + int i; + + for (i = 0; i < data->nsize; i++) + if (data->sizes[i].width == pScreen->width && + data->sizes[i].height == pScreen->height) { + sizeID = (CARD16) i; + break; + } + xfree(data); + } } return sizeID; } diff --git a/nx-X11/programs/Xserver/randr/rrsdispatch.c b/nx-X11/programs/Xserver/randr/rrsdispatch.c index 202222785..3175340fa 100644 --- a/nx-X11/programs/Xserver/randr/rrsdispatch.c +++ b/nx-X11/programs/Xserver/randr/rrsdispatch.c @@ -23,12 +23,13 @@ #include "randrstr.h" static int -SProcRRQueryVersion (ClientPtr client) +SProcRRQueryVersion(ClientPtr client) { register int n; + REQUEST(xRRQueryVersionReq); - REQUEST_SIZE_MATCH(xRRQueryVersionReq); + REQUEST_SIZE_MATCH(xRRQueryVersionReq); swaps(&stuff->length, n); swapl(&stuff->majorVersion, n); swapl(&stuff->minorVersion, n); @@ -36,31 +37,31 @@ SProcRRQueryVersion (ClientPtr client) } static int -SProcRRGetScreenInfo (ClientPtr client) +SProcRRGetScreenInfo(ClientPtr client) { register int n; + REQUEST(xRRGetScreenInfoReq); - REQUEST_SIZE_MATCH(xRRGetScreenInfoReq); + REQUEST_SIZE_MATCH(xRRGetScreenInfoReq); swaps(&stuff->length, n); swapl(&stuff->window, n); return (*ProcRandrVector[stuff->randrReqType]) (client); } static int -SProcRRSetScreenConfig (ClientPtr client) +SProcRRSetScreenConfig(ClientPtr client) { register int n; + REQUEST(xRRSetScreenConfigReq); - if (RRClientKnowsRates (client)) - { - REQUEST_SIZE_MATCH (xRRSetScreenConfigReq); - swaps (&stuff->rate, n); + if (RRClientKnowsRates(client)) { + REQUEST_SIZE_MATCH(xRRSetScreenConfigReq); + swaps(&stuff->rate, n); } - else - { - REQUEST_SIZE_MATCH (xRR1_0SetScreenConfigReq); + else { + REQUEST_SIZE_MATCH(xRR1_0SetScreenConfigReq); } swaps(&stuff->length, n); @@ -72,12 +73,13 @@ SProcRRSetScreenConfig (ClientPtr client) } static int -SProcRRSelectInput (ClientPtr client) +SProcRRSelectInput(ClientPtr client) { register int n; + REQUEST(xRRSelectInputReq); - REQUEST_SIZE_MATCH(xRRSelectInputReq); + REQUEST_SIZE_MATCH(xRRSelectInputReq); swaps(&stuff->length, n); swapl(&stuff->window, n); swaps(&stuff->enable, n); @@ -85,9 +87,10 @@ SProcRRSelectInput (ClientPtr client) } static int -SProcRRGetScreenSizeRange (ClientPtr client) +SProcRRGetScreenSizeRange(ClientPtr client) { int n; + REQUEST(xRRGetScreenSizeRangeReq); REQUEST_SIZE_MATCH(xRRGetScreenSizeRangeReq); @@ -97,9 +100,10 @@ SProcRRGetScreenSizeRange (ClientPtr client) } static int -SProcRRSetScreenSize (ClientPtr client) +SProcRRSetScreenSize(ClientPtr client) { int n; + REQUEST(xRRSetScreenSizeReq); REQUEST_SIZE_MATCH(xRRSetScreenSizeReq); @@ -113,9 +117,10 @@ SProcRRSetScreenSize (ClientPtr client) } static int -SProcRRGetScreenResources (ClientPtr client) +SProcRRGetScreenResources(ClientPtr client) { int n; + REQUEST(xRRGetScreenResourcesReq); REQUEST_SIZE_MATCH(xRRGetScreenResourcesReq); @@ -125,9 +130,10 @@ SProcRRGetScreenResources (ClientPtr client) } static int -SProcRRGetOutputInfo (ClientPtr client) +SProcRRGetOutputInfo(ClientPtr client) { int n; + REQUEST(xRRGetOutputInfoReq);; REQUEST_SIZE_MATCH(xRRGetOutputInfoReq); @@ -138,9 +144,10 @@ SProcRRGetOutputInfo (ClientPtr client) } static int -SProcRRListOutputProperties (ClientPtr client) +SProcRRListOutputProperties(ClientPtr client) { int n; + REQUEST(xRRListOutputPropertiesReq); REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq); @@ -150,9 +157,10 @@ SProcRRListOutputProperties (ClientPtr client) } static int -SProcRRQueryOutputProperty (ClientPtr client) +SProcRRQueryOutputProperty(ClientPtr client) { int n; + REQUEST(xRRQueryOutputPropertyReq); REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq); @@ -163,9 +171,10 @@ SProcRRQueryOutputProperty (ClientPtr client) } static int -SProcRRConfigureOutputProperty (ClientPtr client) +SProcRRConfigureOutputProperty(ClientPtr client) { int n; + REQUEST(xRRConfigureOutputPropertyReq); swaps(&stuff->length, n); @@ -176,37 +185,39 @@ SProcRRConfigureOutputProperty (ClientPtr client) } static int -SProcRRChangeOutputProperty (ClientPtr client) +SProcRRChangeOutputProperty(ClientPtr client) { int n; + REQUEST(xRRChangeOutputPropertyReq); - REQUEST_AT_LEAST_SIZE (xRRChangeOutputPropertyReq); + REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq); swaps(&stuff->length, n); swapl(&stuff->output, n); swapl(&stuff->property, n); swapl(&stuff->type, n); swapl(&stuff->nUnits, n); - switch(stuff->format) { - case 8: - break; - case 16: - SwapRestS(stuff); - break; - case 32: - SwapRestL(stuff); - break; - default: - client->errorValue = stuff->format; - return BadValue; + switch (stuff->format) { + case 8: + break; + case 16: + SwapRestS(stuff); + break; + case 32: + SwapRestL(stuff); + break; + default: + client->errorValue = stuff->format; + return BadValue; } return (*ProcRandrVector[stuff->randrReqType]) (client); } static int -SProcRRDeleteOutputProperty (ClientPtr client) +SProcRRDeleteOutputProperty(ClientPtr client) { int n; + REQUEST(xRRDeleteOutputPropertyReq); REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq); @@ -217,9 +228,10 @@ SProcRRDeleteOutputProperty (ClientPtr client) } static int -SProcRRGetOutputProperty (ClientPtr client) +SProcRRGetOutputProperty(ClientPtr client) { int n; + REQUEST(xRRGetOutputPropertyReq); REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq); @@ -233,10 +245,11 @@ SProcRRGetOutputProperty (ClientPtr client) } static int -SProcRRCreateMode (ClientPtr client) +SProcRRCreateMode(ClientPtr client) { int n; xRRModeInfo *modeinfo; + REQUEST(xRRCreateModeReq); REQUEST_AT_LEAST_SIZE(xRRCreateModeReq); @@ -260,9 +273,10 @@ SProcRRCreateMode (ClientPtr client) } static int -SProcRRDestroyMode (ClientPtr client) +SProcRRDestroyMode(ClientPtr client) { int n; + REQUEST(xRRDestroyModeReq); REQUEST_SIZE_MATCH(xRRDestroyModeReq); @@ -272,9 +286,10 @@ SProcRRDestroyMode (ClientPtr client) } static int -SProcRRAddOutputMode (ClientPtr client) +SProcRRAddOutputMode(ClientPtr client) { int n; + REQUEST(xRRAddOutputModeReq); REQUEST_SIZE_MATCH(xRRAddOutputModeReq); @@ -285,9 +300,10 @@ SProcRRAddOutputMode (ClientPtr client) } static int -SProcRRDeleteOutputMode (ClientPtr client) +SProcRRDeleteOutputMode(ClientPtr client) { int n; + REQUEST(xRRDeleteOutputModeReq); REQUEST_SIZE_MATCH(xRRDeleteOutputModeReq); @@ -298,9 +314,10 @@ SProcRRDeleteOutputMode (ClientPtr client) } static int -SProcRRGetCrtcInfo (ClientPtr client) +SProcRRGetCrtcInfo(ClientPtr client) { int n; + REQUEST(xRRGetCrtcInfoReq); REQUEST_SIZE_MATCH(xRRGetCrtcInfoReq); @@ -311,9 +328,10 @@ SProcRRGetCrtcInfo (ClientPtr client) } static int -SProcRRSetCrtcConfig (ClientPtr client) +SProcRRSetCrtcConfig(ClientPtr client) { int n; + REQUEST(xRRSetCrtcConfigReq); REQUEST_AT_LEAST_SIZE(xRRSetCrtcConfigReq); @@ -330,9 +348,10 @@ SProcRRSetCrtcConfig (ClientPtr client) } static int -SProcRRGetCrtcGammaSize (ClientPtr client) +SProcRRGetCrtcGammaSize(ClientPtr client) { int n; + REQUEST(xRRGetCrtcGammaSizeReq); REQUEST_SIZE_MATCH(xRRGetCrtcGammaSizeReq); @@ -342,9 +361,10 @@ SProcRRGetCrtcGammaSize (ClientPtr client) } static int -SProcRRGetCrtcGamma (ClientPtr client) +SProcRRGetCrtcGamma(ClientPtr client) { int n; + REQUEST(xRRGetCrtcGammaReq); REQUEST_SIZE_MATCH(xRRGetCrtcGammaReq); @@ -354,9 +374,10 @@ SProcRRGetCrtcGamma (ClientPtr client) } static int -SProcRRSetCrtcGamma (ClientPtr client) +SProcRRSetCrtcGamma(ClientPtr client) { int n; + REQUEST(xRRSetCrtcGammaReq); REQUEST_AT_LEAST_SIZE(xRRSetCrtcGammaReq); @@ -367,35 +388,34 @@ SProcRRSetCrtcGamma (ClientPtr client) return (*ProcRandrVector[stuff->randrReqType]) (client); } -int (*SProcRandrVector[RRNumberRequests])(ClientPtr) = { - SProcRRQueryVersion, /* 0 */ +int (*SProcRandrVector[RRNumberRequests]) (ClientPtr) = { + SProcRRQueryVersion, /* 0 */ /* we skip 1 to make old clients fail pretty immediately */ - NULL, /* 1 SProcRandrOldGetScreenInfo */ + NULL, /* 1 SProcRandrOldGetScreenInfo */ /* V1.0 apps share the same set screen config request id */ - SProcRRSetScreenConfig, /* 2 */ - NULL, /* 3 SProcRandrOldScreenChangeSelectInput */ + SProcRRSetScreenConfig, /* 2 */ + NULL, /* 3 SProcRandrOldScreenChangeSelectInput */ /* 3 used to be ScreenChangeSelectInput; deprecated */ - SProcRRSelectInput, /* 4 */ - SProcRRGetScreenInfo, /* 5 */ + SProcRRSelectInput, /* 4 */ + SProcRRGetScreenInfo, /* 5 */ /* V1.2 additions */ - SProcRRGetScreenSizeRange, /* 6 */ - SProcRRSetScreenSize, /* 7 */ - SProcRRGetScreenResources, /* 8 */ - SProcRRGetOutputInfo, /* 9 */ - SProcRRListOutputProperties,/* 10 */ - SProcRRQueryOutputProperty, /* 11 */ - SProcRRConfigureOutputProperty, /* 12 */ - SProcRRChangeOutputProperty,/* 13 */ - SProcRRDeleteOutputProperty,/* 14 */ - SProcRRGetOutputProperty, /* 15 */ - SProcRRCreateMode, /* 16 */ - SProcRRDestroyMode, /* 17 */ - SProcRRAddOutputMode, /* 18 */ - SProcRRDeleteOutputMode, /* 19 */ - SProcRRGetCrtcInfo, /* 20 */ - SProcRRSetCrtcConfig, /* 21 */ - SProcRRGetCrtcGammaSize, /* 22 */ - SProcRRGetCrtcGamma, /* 23 */ - SProcRRSetCrtcGamma, /* 24 */ + SProcRRGetScreenSizeRange, /* 6 */ + SProcRRSetScreenSize, /* 7 */ + SProcRRGetScreenResources, /* 8 */ + SProcRRGetOutputInfo, /* 9 */ + SProcRRListOutputProperties, /* 10 */ + SProcRRQueryOutputProperty, /* 11 */ + SProcRRConfigureOutputProperty, /* 12 */ + SProcRRChangeOutputProperty, /* 13 */ + SProcRRDeleteOutputProperty, /* 14 */ + SProcRRGetOutputProperty, /* 15 */ + SProcRRCreateMode, /* 16 */ + SProcRRDestroyMode, /* 17 */ + SProcRRAddOutputMode, /* 18 */ + SProcRRDeleteOutputMode, /* 19 */ + SProcRRGetCrtcInfo, /* 20 */ + SProcRRSetCrtcConfig, /* 21 */ + SProcRRGetCrtcGammaSize, /* 22 */ + SProcRRGetCrtcGamma, /* 23 */ + SProcRRSetCrtcGamma, /* 24 */ }; - diff --git a/nx-X11/programs/Xserver/randr/rrxinerama.c b/nx-X11/programs/Xserver/randr/rrxinerama.c index 5061fada2..31b750d64 100644 --- a/nx-X11/programs/Xserver/randr/rrxinerama.c +++ b/nx-X11/programs/Xserver/randr/rrxinerama.c @@ -114,8 +114,8 @@ extern Bool noRRXineramaExtension; int ProcRRXineramaQueryVersion(ClientPtr client) { - xPanoramiXQueryVersionReply rep; - register int n; + xPanoramiXQueryVersionReply rep; + register int n; REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq); rep.type = X_Reply; @@ -123,13 +123,13 @@ ProcRRXineramaQueryVersion(ClientPtr client) rep.sequenceNumber = client->sequence; rep.majorVersion = RR_XINERAMA_MAJOR_VERSION; rep.minorVersion = RR_XINERAMA_MINOR_VERSION; - if(client->swapped) { + if (client->swapped) { swaps(&rep.sequenceNumber, n); swapl(&rep.length, n); swaps(&rep.majorVersion, n); swaps(&rep.minorVersion, n); } - WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *)&rep); + WriteToClient(client, sizeof(xPanoramiXQueryVersionReply), (char *) &rep); return (client->noClientException); } @@ -137,29 +137,28 @@ int ProcRRXineramaGetState(ClientPtr client) { REQUEST(xPanoramiXGetStateReq); - WindowPtr pWin; - xPanoramiXGetStateReply rep; - register int n, rc; - ScreenPtr pScreen; - rrScrPrivPtr pScrPriv; - Bool active = FALSE; + WindowPtr pWin; + xPanoramiXGetStateReply rep; + register int n, rc; + ScreenPtr pScreen; + rrScrPrivPtr pScrPriv; + Bool active = FALSE; REQUEST_SIZE_MATCH(xPanoramiXGetStateReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif - if(rc != Success) - return rc; +#endif + if (rc != Success) + return rc; pScreen = pWin->drawable.pScreen; pScrPriv = rrGetScrPriv(pScreen); - if (pScrPriv) - { - /* XXX do we need more than this? */ - active = TRUE; + if (pScrPriv) { + /* XXX do we need more than this? */ + active = TRUE; } rep.type = X_Reply; @@ -167,72 +166,71 @@ ProcRRXineramaGetState(ClientPtr client) rep.sequenceNumber = client->sequence; rep.state = active; rep.window = stuff->window; - if(client->swapped) { - swaps (&rep.sequenceNumber, n); - swapl (&rep.length, n); - swapl (&rep.window, n); + if (client->swapped) { + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.window, n); } - WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *)&rep); + WriteToClient(client, sizeof(xPanoramiXGetStateReply), (char *) &rep); return client->noClientException; } static Bool -RRXineramaCrtcActive (RRCrtcPtr crtc) +RRXineramaCrtcActive(RRCrtcPtr crtc) { return crtc->mode != NULL && crtc->numOutputs > 0; } static int -RRXineramaScreenCount (ScreenPtr pScreen) +RRXineramaScreenCount(ScreenPtr pScreen) { - int i, n; + int i, n; n = 0; - if (rrGetScrPriv (pScreen)) - { - rrScrPriv(pScreen); - for (i = 0; i < pScrPriv->numCrtcs; i++) - if (RRXineramaCrtcActive (pScrPriv->crtcs[i])) - n++; + if (rrGetScrPriv(pScreen)) { + rrScrPriv(pScreen); + for (i = 0; i < pScrPriv->numCrtcs; i++) + if (RRXineramaCrtcActive(pScrPriv->crtcs[i])) + n++; } return n; } static Bool -RRXineramaScreenActive (ScreenPtr pScreen) +RRXineramaScreenActive(ScreenPtr pScreen) { - return RRXineramaScreenCount (pScreen) > 0; + return RRXineramaScreenCount(pScreen) > 0; } int ProcRRXineramaGetScreenCount(ClientPtr client) { REQUEST(xPanoramiXGetScreenCountReq); - WindowPtr pWin; - xPanoramiXGetScreenCountReply rep; - register int n, rc; + WindowPtr pWin; + xPanoramiXGetScreenCountReply rep; + register int n, rc; REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; rep.type = X_Reply; rep.length = 0; rep.sequenceNumber = client->sequence; - rep.ScreenCount = RRXineramaScreenCount (pWin->drawable.pScreen); + rep.ScreenCount = RRXineramaScreenCount(pWin->drawable.pScreen); rep.window = stuff->window; - if(client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.window, n); + if (client->swapped) { + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.window, n); } - WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *)&rep); + WriteToClient(client, sizeof(xPanoramiXGetScreenCountReply), (char *) &rep); return client->noClientException; } @@ -240,20 +238,20 @@ int ProcRRXineramaGetScreenSize(ClientPtr client) { REQUEST(xPanoramiXGetScreenSizeReq); - WindowPtr pWin, pRoot; - ScreenPtr pScreen; - xPanoramiXGetScreenSizeReply rep; - register int n, rc; + WindowPtr pWin, pRoot; + ScreenPtr pScreen; + xPanoramiXGetScreenSizeReply rep; + register int n, rc; REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq); - #ifndef NXAGENT_SERVER +#ifndef NXAGENT_SERVER rc = dixLookupWindow(&pWin, stuff->window, client, DixGetAttrAccess); - #else +#else pWin = SecurityLookupWindow(stuff->window, client, SecurityReadAccess); rc = pWin ? Success : BadWindow; - #endif +#endif if (rc != Success) - return rc; + return rc; pScreen = pWin->drawable.pScreen; pRoot = WindowTable[pScreen->myNum]; @@ -261,26 +259,26 @@ ProcRRXineramaGetScreenSize(ClientPtr client) rep.type = X_Reply; rep.length = 0; rep.sequenceNumber = client->sequence; - rep.width = pRoot->drawable.width; + rep.width = pRoot->drawable.width; rep.height = pRoot->drawable.height; rep.window = stuff->window; rep.screen = stuff->screen; - if(client->swapped) { - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.width, n); - swapl(&rep.height, n); - swapl(&rep.window, n); - swapl(&rep.screen, n); + if (client->swapped) { + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.width, n); + swapl(&rep.height, n); + swapl(&rep.window, n); + swapl(&rep.screen, n); } - WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *)&rep); + WriteToClient(client, sizeof(xPanoramiXGetScreenSizeReply), (char *) &rep); return client->noClientException; } int ProcRRXineramaIsActive(ClientPtr client) { - xXineramaIsActiveReply rep; + xXineramaIsActiveReply rep; REQUEST_SIZE_MATCH(xXineramaIsActiveReq); @@ -288,12 +286,13 @@ ProcRRXineramaIsActive(ClientPtr client) rep.type = X_Reply; rep.length = 0; rep.sequenceNumber = client->sequence; - rep.state = RRXineramaScreenActive (screenInfo.screens[RR_XINERAMA_SCREEN]); - if(client->swapped) { - register int n; - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.state, n); + rep.state = RRXineramaScreenActive(screenInfo.screens[RR_XINERAMA_SCREEN]); + if (client->swapped) { + register int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.state, n); } WriteToClient(client, sizeof(xXineramaIsActiveReply), (char *) &rep); return client->noClientException; @@ -302,55 +301,57 @@ ProcRRXineramaIsActive(ClientPtr client) int ProcRRXineramaQueryScreens(ClientPtr client) { - xXineramaQueryScreensReply rep; - ScreenPtr pScreen = screenInfo.screens[RR_XINERAMA_SCREEN]; + xXineramaQueryScreensReply rep; + ScreenPtr pScreen = screenInfo.screens[RR_XINERAMA_SCREEN]; REQUEST_SIZE_MATCH(xXineramaQueryScreensReq); - if (RRXineramaScreenActive (pScreen)) - { - rrScrPriv(pScreen); - if (pScrPriv->numCrtcs == 0 || pScrPriv->numOutputs == 0) - RRGetInfo (pScreen); + if (RRXineramaScreenActive(pScreen)) { + rrScrPriv(pScreen); + if (pScrPriv->numCrtcs == 0 || pScrPriv->numOutputs == 0) + RRGetInfo(pScreen); } rep.type = X_Reply; rep.sequenceNumber = client->sequence; - rep.number = RRXineramaScreenCount (pScreen); + rep.number = RRXineramaScreenCount(pScreen); rep.length = rep.number * sz_XineramaScreenInfo >> 2; - if(client->swapped) { - register int n; - swaps(&rep.sequenceNumber, n); - swapl(&rep.length, n); - swapl(&rep.number, n); + if (client->swapped) { + register int n; + + swaps(&rep.sequenceNumber, n); + swapl(&rep.length, n); + swapl(&rep.number, n); } - WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *)&rep); - - if(rep.number) { - rrScrPriv(pScreen); - xXineramaScreenInfo scratch; - int i; - - for(i = 0; i < pScrPriv->numCrtcs; i++) { - RRCrtcPtr crtc = pScrPriv->crtcs[i]; - if (RRXineramaCrtcActive (crtc)) - { - int width, height; - RRCrtcGetScanoutSize (crtc, &width, &height); - scratch.x_org = crtc->x; - scratch.y_org = crtc->y; - scratch.width = width; - scratch.height = height; - if(client->swapped) { - register int n; - swaps(&scratch.x_org, n); - swaps(&scratch.y_org, n); - swaps(&scratch.width, n); - swaps(&scratch.height, n); - } - WriteToClient(client, sz_XineramaScreenInfo, (char *)&scratch); - } - } + WriteToClient(client, sizeof(xXineramaQueryScreensReply), (char *) &rep); + + if (rep.number) { + rrScrPriv(pScreen); + xXineramaScreenInfo scratch; + int i; + + for (i = 0; i < pScrPriv->numCrtcs; i++) { + RRCrtcPtr crtc = pScrPriv->crtcs[i]; + + if (RRXineramaCrtcActive(crtc)) { + int width, height; + + RRCrtcGetScanoutSize(crtc, &width, &height); + scratch.x_org = crtc->x; + scratch.y_org = crtc->y; + scratch.width = width; + scratch.height = height; + if (client->swapped) { + register int n; + + swaps(&scratch.x_org, n); + swaps(&scratch.y_org, n); + swaps(&scratch.width, n); + swaps(&scratch.height, n); + } + WriteToClient(client, sz_XineramaScreenInfo, (char *) &scratch); + } + } } return client->noClientException; @@ -361,18 +362,18 @@ ProcRRXineramaDispatch(ClientPtr client) { REQUEST(xReq); switch (stuff->data) { - case X_PanoramiXQueryVersion: - return ProcRRXineramaQueryVersion(client); - case X_PanoramiXGetState: - return ProcRRXineramaGetState(client); - case X_PanoramiXGetScreenCount: - return ProcRRXineramaGetScreenCount(client); - case X_PanoramiXGetScreenSize: - return ProcRRXineramaGetScreenSize(client); - case X_XineramaIsActive: - return ProcRRXineramaIsActive(client); - case X_XineramaQueryScreens: - return ProcRRXineramaQueryScreens(client); + case X_PanoramiXQueryVersion: + return ProcRRXineramaQueryVersion(client); + case X_PanoramiXGetState: + return ProcRRXineramaGetState(client); + case X_PanoramiXGetScreenCount: + return ProcRRXineramaGetScreenCount(client); + case X_PanoramiXGetScreenSize: + return ProcRRXineramaGetScreenSize(client); + case X_XineramaIsActive: + return ProcRRXineramaIsActive(client); + case X_XineramaQueryScreens: + return ProcRRXineramaQueryScreens(client); } return BadRequest; } @@ -380,12 +381,13 @@ ProcRRXineramaDispatch(ClientPtr client) /* SProc */ static int -SProcRRXineramaQueryVersion (ClientPtr client) +SProcRRXineramaQueryVersion(ClientPtr client) { REQUEST(xPanoramiXQueryVersionReq); register int n; - swaps(&stuff->length,n); - REQUEST_SIZE_MATCH (xPanoramiXQueryVersionReq); + + swaps(&stuff->length, n); + REQUEST_SIZE_MATCH(xPanoramiXQueryVersionReq); return ProcRRXineramaQueryVersion(client); } @@ -394,9 +396,10 @@ SProcRRXineramaGetState(ClientPtr client) { REQUEST(xPanoramiXGetStateReq); register int n; - swaps (&stuff->length, n); + + swaps(&stuff->length, n); REQUEST_SIZE_MATCH(xPanoramiXGetStateReq); - swapl (&stuff->window, n); + swapl(&stuff->window, n); return ProcRRXineramaGetState(client); } @@ -405,9 +408,10 @@ SProcRRXineramaGetScreenCount(ClientPtr client) { REQUEST(xPanoramiXGetScreenCountReq); register int n; - swaps (&stuff->length, n); + + swaps(&stuff->length, n); REQUEST_SIZE_MATCH(xPanoramiXGetScreenCountReq); - swapl (&stuff->window, n); + swapl(&stuff->window, n); return ProcRRXineramaGetScreenCount(client); } @@ -416,10 +420,11 @@ SProcRRXineramaGetScreenSize(ClientPtr client) { REQUEST(xPanoramiXGetScreenSizeReq); register int n; - swaps (&stuff->length, n); + + swaps(&stuff->length, n); REQUEST_SIZE_MATCH(xPanoramiXGetScreenSizeReq); - swapl (&stuff->window, n); - swapl (&stuff->screen, n); + swapl(&stuff->window, n); + swapl(&stuff->screen, n); return ProcRRXineramaGetScreenSize(client); } @@ -428,7 +433,8 @@ SProcRRXineramaIsActive(ClientPtr client) { REQUEST(xXineramaIsActiveReq); register int n; - swaps (&stuff->length, n); + + swaps(&stuff->length, n); REQUEST_SIZE_MATCH(xXineramaIsActiveReq); return ProcRRXineramaIsActive(client); } @@ -438,7 +444,8 @@ SProcRRXineramaQueryScreens(ClientPtr client) { REQUEST(xXineramaQueryScreensReq); register int n; - swaps (&stuff->length, n); + + swaps(&stuff->length, n); REQUEST_SIZE_MATCH(xXineramaQueryScreensReq); return ProcRRXineramaQueryScreens(client); } @@ -448,24 +455,24 @@ SProcRRXineramaDispatch(ClientPtr client) { REQUEST(xReq); switch (stuff->data) { - case X_PanoramiXQueryVersion: - return SProcRRXineramaQueryVersion(client); - case X_PanoramiXGetState: - return SProcRRXineramaGetState(client); - case X_PanoramiXGetScreenCount: - return SProcRRXineramaGetScreenCount(client); - case X_PanoramiXGetScreenSize: - return SProcRRXineramaGetScreenSize(client); - case X_XineramaIsActive: - return SProcRRXineramaIsActive(client); - case X_XineramaQueryScreens: - return SProcRRXineramaQueryScreens(client); + case X_PanoramiXQueryVersion: + return SProcRRXineramaQueryVersion(client); + case X_PanoramiXGetState: + return SProcRRXineramaGetState(client); + case X_PanoramiXGetScreenCount: + return SProcRRXineramaGetScreenCount(client); + case X_PanoramiXGetScreenSize: + return SProcRRXineramaGetScreenSize(client); + case X_XineramaIsActive: + return SProcRRXineramaIsActive(client); + case X_XineramaQueryScreens: + return SProcRRXineramaQueryScreens(client); } return BadRequest; } static void -RRXineramaResetProc(ExtensionEntry* extEntry) +RRXineramaResetProc(ExtensionEntry * extEntry) { } @@ -473,8 +480,8 @@ void RRXineramaExtensionInit(void) { #ifdef PANORAMIX - if(!noPanoramiXExtension) - return; + if (!noPanoramiXExtension) + return; #endif /* @@ -483,11 +490,10 @@ RRXineramaExtensionInit(void) * screen, just don't even try. */ if (screenInfo.numScreens > 1) - return; + return; - (void) AddExtension(PANORAMIX_PROTOCOL_NAME, 0,0, - ProcRRXineramaDispatch, - SProcRRXineramaDispatch, - RRXineramaResetProc, - StandardMinorOpcode); + (void) AddExtension(PANORAMIX_PROTOCOL_NAME, 0, 0, + ProcRRXineramaDispatch, + SProcRRXineramaDispatch, + RRXineramaResetProc, StandardMinorOpcode); } -- cgit v1.2.3