aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/programs/Xserver
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/programs/Xserver')
-rw-r--r--nx-X11/programs/Xserver/randr/panoramiXproto.h206
-rw-r--r--nx-X11/programs/Xserver/randr/randr.c404
-rw-r--r--nx-X11/programs/Xserver/randr/randr.h18
-rw-r--r--nx-X11/programs/Xserver/randr/randrproto.h759
-rw-r--r--nx-X11/programs/Xserver/randr/randrstr.h585
-rw-r--r--nx-X11/programs/Xserver/randr/registry.h8
-rw-r--r--nx-X11/programs/Xserver/randr/rrcrtc.c1023
-rw-r--r--nx-X11/programs/Xserver/randr/rrdispatch.c267
-rw-r--r--nx-X11/programs/Xserver/randr/rrinfo.c289
-rw-r--r--nx-X11/programs/Xserver/randr/rrmode.c429
-rw-r--r--nx-X11/programs/Xserver/randr/rroutput.c489
-rw-r--r--nx-X11/programs/Xserver/randr/rrpointer.c142
-rw-r--r--nx-X11/programs/Xserver/randr/rrproperty.c833
-rw-r--r--nx-X11/programs/Xserver/randr/rrscreen.c1272
-rw-r--r--nx-X11/programs/Xserver/randr/rrsdispatch.c166
-rw-r--r--nx-X11/programs/Xserver/randr/rrxinerama.c320
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 <nx-X11/extensions/render.h> /* we share subpixel order information */
+#include <nx-X11/extensions/render.h> /* we share subpixel order information */
#include "picturestr.h"
#endif
#include <nx-X11/Xfuncproto.h>
@@ -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);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 01:45:19 +0000