/*
** Top level dispatcher; all commands are executed from here down.
*/
static int __glXDispatch(ClientPtr client)
{
REQUEST(xGLXSingleReq);
CARD8 opcode;
int (*proc)(__GLXclientState *cl, GLbyte *pc);
__GLXclientState *cl;
opcode = stuff->glxCode;
cl = __glXClients[client->index];
if (!cl) {
cl = __glXCalloc(1, sizeof(__GLXclientState));
__glXClients[client->index] = cl;
if (!cl) {
return BadAlloc;
}
cl->be_displays = __glXCalloc(screenInfo.numScreens, sizeof(Display *));
if (!cl->be_displays) {
__glXFree( cl );
return BadAlloc;
}
}
if (!cl->inUse) {
/*
** This is first request from this client. Associate a resource
** with the client so we will be notified when the client dies.
*/
XID xid = FakeClientID(client->index);
if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
return BadAlloc;
}
ResetClientState(client->index);
cl->largeCmdRequestsTotal = 0;
cl->inUse = GL_TRUE;
cl->client = client;
}
/*
** Check for valid opcode.
*/
if (opcode >= __GLX_SINGLE_TABLE_SIZE) {
return BadRequest;
}
/*
** Use the opcode to index into the procedure table.
*/
proc = __glXSingleTable[opcode];
return (*proc)(cl, (GLbyte *) stuff);
}
int
LoadAuthorization (void)
{
FILE *f;
Xauth *auth;
int i;
int count = 0;
#if !defined(WIN32) && !defined(__UNIXOS2__)
char *buf;
#endif
ShouldLoadAuth = FALSE;
if (!authorization_file)
return 0;
#if !defined(WIN32) && !defined(__UNIXOS2__)
buf = xalloc (strlen(authorization_file) + 5);
if (!buf)
return -1;
sprintf (buf, "cat %s", authorization_file);
f = Popen (buf, "r");
xfree (buf);
#else
f = fopen (authorization_file, "r");
#endif
if (!f)
return -1;
while ((auth = XauReadAuth (f)) != 0) {
for (i = 0; i < NUM_AUTHORIZATION; i++) {
if (protocols[i].name_length == auth->name_length &&
memcmp (protocols[i].name, auth->name, (int) auth->name_length) == 0 &&
protocols[i].Add)
{
++count;
(*protocols[i].Add) (auth->data_length, auth->data,
FakeClientID(0));
}
}
XauDisposeAuth (auth);
}
#if !defined(WIN32) && !defined(__UNIXOS2__)
if (Pclose (f) != 0)
return -1;
#else
fclose (f);
#endif
return count;
}
int
AddAuthorization (unsigned name_length, char *name, unsigned data_length, char *data)
{
int i;
for (i = 0; i < NUM_AUTHORIZATION; i++) {
if (protocols[i].name_length == name_length &&
memcmp (protocols[i].name, name, (int) name_length) == 0 &&
protocols[i].Add)
{
return (*protocols[i].Add) (data_length, data, FakeClientID(0));
}
}
return 0;
}
Bool
mfbAllocatePrivates(ScreenPtr pScreen, DevPrivateKey *pGCKey)
{
if (mfbGeneration != serverGeneration)
{
visual.vid = FakeClientID(0);
VID = visual.vid;
mfbGeneration = serverGeneration;
}
if (pGCKey)
*pGCKey = mfbGCPrivateKey;
pScreen->GetWindowPixmap = mfbGetWindowPixmap;
pScreen->SetWindowPixmap = mfbSetWindowPixmap;
return dixRequestPrivate(mfbGCPrivateKey, sizeof(mfbPrivGC));
}
GrabPtr
CreateGrab(
int client,
DeviceIntPtr device,
DeviceIntPtr modDevice,
WindowPtr window,
GrabType grabtype,
GrabMask *mask,
GrabParameters *param,
int type,
KeyCode keybut, /* key or button */
WindowPtr confineTo,
CursorPtr cursor)
{
GrabPtr grab;
grab = calloc(1, sizeof(GrabRec));
if (!grab)
return (GrabPtr)NULL;
grab->resource = FakeClientID(client);
grab->device = device;
grab->window = window;
grab->eventMask = mask->core; /* same for XI */
grab->deviceMask = 0;
grab->ownerEvents = param->ownerEvents;
grab->keyboardMode = param->this_device_mode;
grab->pointerMode = param->other_devices_mode;
grab->modifiersDetail.exact = param->modifiers;
grab->modifiersDetail.pMask = NULL;
grab->modifierDevice = modDevice;
grab->type = type;
grab->grabtype = grabtype;
grab->detail.exact = keybut;
grab->detail.pMask = NULL;
grab->confineTo = confineTo;
grab->cursor = cursor;
grab->next = NULL;
if (grabtype == GRABTYPE_XI2)
memcpy(grab->xi2mask, mask->xi2mask, sizeof(mask->xi2mask));
if (cursor)
cursor->refcnt++;
return grab;
}
static Bool
cfb8_32WidSetupScreen(
ScreenPtr pScreen,
int xsize, int ysize, /* in pixels */
int dpix, int dpiy
){
if (!cfb8_32WidAllocatePrivates(pScreen))
return FALSE;
pScreen->defColormap = FakeClientID(0);
/* let CreateDefColormap do whatever it wants for pixels */
pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
pScreen->QueryBestSize = mfbQueryBestSize;
/* SaveScreen */
pScreen->GetImage = cfb8_32WidGetImage;
pScreen->GetSpans = cfb8_32WidGetSpans;
pScreen->CreateWindow = cfb8_32WidCreateWindow;
pScreen->DestroyWindow = cfb8_32WidDestroyWindow;
pScreen->PositionWindow = cfb8_32WidPositionWindow;
pScreen->ChangeWindowAttributes = cfb8_32WidChangeWindowAttributes;
pScreen->RealizeWindow = cfb32MapWindow; /* OK */
pScreen->UnrealizeWindow = cfb32UnmapWindow; /* OK */
pScreen->PaintWindowBackground = cfb8_32WidPaintWindow;
pScreen->PaintWindowBorder = cfb8_32WidPaintWindow;
pScreen->CopyWindow = cfb8_32WidCopyWindow;
pScreen->CreatePixmap = cfb32CreatePixmap; /* OK */
pScreen->DestroyPixmap = cfb32DestroyPixmap; /* OK */
pScreen->RealizeFont = mfbRealizeFont;
pScreen->UnrealizeFont = mfbUnrealizeFont;
pScreen->CreateGC = cfb8_32WidCreateGC;
pScreen->CreateColormap = miInitializeColormap;
pScreen->DestroyColormap = (void (*)())NoopDDA;
pScreen->InstallColormap = miInstallColormap;
pScreen->UninstallColormap = miUninstallColormap;
pScreen->ListInstalledColormaps = miListInstalledColormaps;
pScreen->StoreColors = (void (*)())NoopDDA;
pScreen->ResolveColor = miResolveColor;
pScreen->BitmapToRegion = mfbPixmapToRegion;
mfbRegisterCopyPlaneProc (pScreen, cfbCopyPlane);
return TRUE;
}
static Bool
cfb24_32SetupScreen(
ScreenPtr pScreen,
pointer pbits, /* pointer to screen bitmap */
int xsize, int ysize, /* in pixels */
int dpix, int dpiy, /* dots per inch */
int width /* pixel width of frame buffer */
){
if (!cfb24_32AllocatePrivates(pScreen))
return FALSE;
pScreen->defColormap = FakeClientID(0);
/* let CreateDefColormap do whatever it wants for pixels */
pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
pScreen->QueryBestSize = mfbQueryBestSize;
/* SaveScreen */
pScreen->GetImage = cfb24_32GetImage;
pScreen->GetSpans = cfb24_32GetSpans;
pScreen->CreateWindow = cfb24_32CreateWindow;
pScreen->DestroyWindow = cfb24_32DestroyWindow;
pScreen->PositionWindow = cfb24_32PositionWindow;
pScreen->ChangeWindowAttributes = cfb24_32ChangeWindowAttributes;
pScreen->RealizeWindow = cfb24MapWindow; /* OK */
pScreen->UnrealizeWindow = cfb24UnmapWindow; /* OK */
pScreen->PaintWindowBackground = cfb24PaintWindow; /* OK */
pScreen->PaintWindowBorder = cfb24PaintWindow; /* OK */
pScreen->CopyWindow = cfb24_32CopyWindow;
pScreen->CreatePixmap = cfb24_32CreatePixmap;
pScreen->DestroyPixmap = cfb24_32DestroyPixmap;
pScreen->RealizeFont = mfbRealizeFont;
pScreen->UnrealizeFont = mfbUnrealizeFont;
pScreen->CreateGC = cfb24_32CreateGC;
pScreen->CreateColormap = miInitializeColormap;
pScreen->DestroyColormap = DestroyColormapNoop;
pScreen->InstallColormap = miInstallColormap;
pScreen->UninstallColormap = miUninstallColormap;
pScreen->ListInstalledColormaps = miListInstalledColormaps;
pScreen->StoreColors = StoreColorsNoop;
pScreen->ResolveColor = miResolveColor;
pScreen->BitmapToRegion = mfbPixmapToRegion;
mfbRegisterCopyPlaneProc (pScreen, miCopyPlane);
return TRUE;
}
GrabPtr
CreateGrab(
int client,
DeviceIntPtr device,
WindowPtr window,
Mask eventMask,
Bool ownerEvents, Bool keyboardMode, Bool pointerMode,
DeviceIntPtr modDevice,
unsigned short modifiers,
int type,
KeyCode keybut, /* key or button */
WindowPtr confineTo,
CursorPtr cursor)
{
GrabPtr grab;
grab = (GrabPtr)xalloc(sizeof(GrabRec));
if (!grab)
return (GrabPtr)NULL;
grab->resource = FakeClientID(client);
grab->device = device;
grab->coreGrab = ((device == inputInfo.keyboard) ||
(device == inputInfo.pointer));
grab->window = window;
grab->eventMask = eventMask;
grab->ownerEvents = ownerEvents;
grab->keyboardMode = keyboardMode;
grab->pointerMode = pointerMode;
grab->modifiersDetail.exact = modifiers;
grab->modifiersDetail.pMask = NULL;
grab->modifierDevice = modDevice;
grab->coreMods = ((modDevice == inputInfo.keyboard) ||
(modDevice == inputInfo.pointer));
grab->type = type;
grab->detail.exact = keybut;
grab->detail.pMask = NULL;
grab->confineTo = confineTo;
grab->cursor = cursor;
if (cursor)
cursor->refcnt++;
return grab;
}
static RRModePtr
RRModeCreate (xRRModeInfo *modeInfo,
const char *name,
ScreenPtr userScreen)
{
RRModePtr mode, *newModes;
if (!RRInit ())
return NULL;
mode = xalloc (sizeof (RRModeRec) + modeInfo->nameLength + 1);
if (!mode)
return NULL;
mode->refcnt = 1;
mode->mode = *modeInfo;
mode->name = (char *) (mode + 1);
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));
else
newModes = xalloc (sizeof (RRModePtr));
if (!newModes)
{
xfree (mode);
return NULL;
}
mode->mode.id = FakeClientID(0);
if (!AddResource (mode->mode.id, RRModeType, (pointer) mode))
return NULL;
modes = newModes;
modes[num_modes++] = mode;
/*
* give the caller a reference to this mode
*/
++mode->refcnt;
return mode;
}
XID
GenerateAuthorization(unsigned name_length,
const char *name,
unsigned data_length,
const char *data,
unsigned *data_length_return, char **data_return)
{
int i;
for (i = 0; i < NUM_AUTHORIZATION; i++) {
if (protocols[i].name_length == name_length &&
memcmp(protocols[i].name, name, (int) name_length) == 0 &&
protocols[i].Generate) {
return (*protocols[i].Generate) (data_length, data,
FakeClientID(0),
data_length_return, data_return);
}
}
return -1;
}
GrabPtr
CreateGrab(int client, DeviceIntPtr device, DeviceIntPtr modDevice,
WindowPtr window, enum InputLevel grabtype, GrabMask *mask,
GrabParameters *param, int type,
KeyCode keybut, /* key or button */
WindowPtr confineTo, CursorPtr cursor)
{
GrabPtr grab;
grab = AllocGrab();
if (!grab)
return (GrabPtr) NULL;
grab->resource = FakeClientID(client);
grab->device = device;
grab->window = window;
if (grabtype == CORE || grabtype == XI)
grab->eventMask = mask->core; /* same for XI */
else
grab->eventMask = 0;
grab->deviceMask = 0;
grab->ownerEvents = param->ownerEvents;
grab->keyboardMode = param->this_device_mode;
grab->pointerMode = param->other_devices_mode;
grab->modifiersDetail.exact = param->modifiers;
grab->modifiersDetail.pMask = NULL;
grab->modifierDevice = modDevice;
grab->type = type;
grab->grabtype = grabtype;
grab->detail.exact = keybut;
grab->detail.pMask = NULL;
grab->confineTo = confineTo;
grab->cursor = cursor;
grab->next = NULL;
if (grabtype == XI2)
xi2mask_merge(grab->xi2mask, mask->xi2mask);
if (cursor)
cursor->refcnt++;
return grab;
}
static int
LoadAuthorization(void)
{
FILE *f;
Xauth *auth;
int i;
int count = 0;
ShouldLoadAuth = FALSE;
if (!authorization_file)
return 0;
errno = 0;
f = Fopen(authorization_file, "r");
if (!f) {
LogMessageVerb(X_ERROR, 0,
"Failed to open authorization file \"%s\": %s\n",
authorization_file,
errno != 0 ? strerror(errno) : "Unknown error");
return -1;
}
while ((auth = XauReadAuth(f)) != 0) {
for (i = 0; i < NUM_AUTHORIZATION; i++) {
if (protocols[i].name_length == auth->name_length &&
memcmp(protocols[i].name, auth->name,
(int) auth->name_length) == 0 && protocols[i].Add) {
++count;
(*protocols[i].Add) (auth->data_length, auth->data,
FakeClientID(0));
}
}
XauDisposeAuth(auth);
}
Fclose(f);
return count;
}
static int
SecurityEventSelectForAuthorization(
SecurityAuthorizationPtr pAuth,
ClientPtr client,
Mask mask)
{
OtherClients *pEventClient;
for (pEventClient = pAuth->eventClients;
pEventClient;
pEventClient = pEventClient->next)
{
if (SameClient(pEventClient, client))
{
if (mask == 0)
FreeResource(pEventClient->resource, RT_NONE);
else
pEventClient->mask = mask;
return Success;
}
}
pEventClient = malloc(sizeof(OtherClients));
if (!pEventClient)
return BadAlloc;
pEventClient->mask = mask;
pEventClient->resource = FakeClientID(client->index);
pEventClient->next = pAuth->eventClients;
if (!AddResource(pEventClient->resource, RTEventClient,
(pointer)pAuth))
{
free(pEventClient);
return BadAlloc;
}
pAuth->eventClients = pEventClient;
return Success;
} /* SecurityEventSelectForAuthorization */
void
AppleWMExtensionInit(void)
{
ExtensionEntry* extEntry;
ClientType = CreateNewResourceType(WMFreeClient);
EventType = CreateNewResourceType(WMFreeEvents);
eventResource = FakeClientID(0);
if (ClientType && EventType &&
(extEntry = AddExtension(APPLEWMNAME,
AppleWMNumberEvents,
AppleWMNumberErrors,
ProcAppleWMDispatch,
SProcAppleWMDispatch,
AppleWMResetProc,
StandardMinorOpcode))) {
WMReqCode = (unsigned char)extEntry->base;
WMErrorBase = extEntry->errorBase;
WMEventBase = extEntry->eventBase;
EventSwapVector[WMEventBase] = (EventSwapPtr) SNotifyEvent;
}
}
/* for lack of a better way, a window is created that covers the area and
when its deleted, it's invalidated */
static int
rdpInvalidateArea(ScreenPtr pScreen, int x, int y, int cx, int cy)
{
WindowPtr pWin;
int result;
int attri;
XID attributes[4];
Mask mask;
DEBUG_OUT(("rdpInvalidateArea:\n"));
mask = 0;
attri = 0;
attributes[attri++] = pScreen->blackPixel;
mask |= CWBackPixel;
attributes[attri++] = xTrue;
mask |= CWOverrideRedirect;
if (g_wid == 0)
{
g_wid = FakeClientID(0);
}
pWin = CreateWindow(g_wid, pScreen->root,
x, y, cx, cy, 0, InputOutput, mask,
attributes, 0, serverClient,
wVisual(pScreen->root), &result);
if (result == 0)
{
g_invalidate_window = pWin;
MapWindow(pWin, serverClient);
DeleteWindow(pWin, None);
g_invalidate_window = pWin;
}
return 0;
}
static int
ProcShapeSelectInput(ClientPtr client)
{
REQUEST(xShapeSelectInputReq);
WindowPtr pWin;
ShapeEventPtr pShapeEvent, pNewShapeEvent, *pHead;
XID clientResource;
int rc;
REQUEST_SIZE_MATCH(xShapeSelectInputReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
if (rc != Success)
return rc;
rc = dixLookupResourceByType((pointer *) &pHead, pWin->drawable.id,
ShapeEventType, client, DixWriteAccess);
if (rc != Success && rc != BadValue)
return rc;
switch (stuff->enable) {
case xTrue:
if (pHead) {
/* check for existing entry. */
for (pShapeEvent = *pHead;
pShapeEvent; pShapeEvent = pShapeEvent->next) {
if (pShapeEvent->client == client)
return Success;
}
}
/* build the entry */
pNewShapeEvent = malloc(sizeof(ShapeEventRec));
if (!pNewShapeEvent)
return BadAlloc;
pNewShapeEvent->next = 0;
pNewShapeEvent->client = client;
pNewShapeEvent->window = pWin;
/*
* add a resource that will be deleted when
* the client goes away
*/
clientResource = FakeClientID(client->index);
pNewShapeEvent->clientResource = clientResource;
if (!AddResource(clientResource, ClientType, (pointer) pNewShapeEvent))
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 = malloc(sizeof(ShapeEventPtr));
if (!pHead ||
!AddResource(pWin->drawable.id, ShapeEventType,
(pointer) pHead)) {
FreeResource(clientResource, RT_NONE);
return BadAlloc;
}
*pHead = 0;
}
pNewShapeEvent->next = *pHead;
*pHead = pNewShapeEvent;
break;
case xFalse:
/* delete the interest */
if (pHead) {
pNewShapeEvent = 0;
for (pShapeEvent = *pHead; pShapeEvent;
pShapeEvent = pShapeEvent->next) {
if (pShapeEvent->client == client)
break;
pNewShapeEvent = pShapeEvent;
}
if (pShapeEvent) {
FreeResource(pShapeEvent->clientResource, ClientType);
if (pNewShapeEvent)
pNewShapeEvent->next = pShapeEvent->next;
else
*pHead = pShapeEvent->next;
free(pShapeEvent);
}
}
break;
default:
client->errorValue = stuff->enable;
return BadValue;
}
return Success;
}
static int
ProcPanoramiXShmCreatePixmap(ClientPtr client)
{
ScreenPtr pScreen = NULL;
PixmapPtr pMap = NULL;
DrawablePtr pDraw;
DepthPtr pDepth;
int i, j, result, rc;
ShmDescPtr shmdesc;
REQUEST(xShmCreatePixmapReq);
unsigned int width, height, depth;
unsigned long size;
PanoramiXRes *newPix;
REQUEST_SIZE_MATCH(xShmCreatePixmapReq);
client->errorValue = stuff->pid;
if (!sharedPixmaps)
return BadImplementation;
LEGAL_NEW_RESOURCE(stuff->pid, client);
rc = dixLookupDrawable(&pDraw, stuff->drawable, client, M_ANY,
DixGetAttrAccess);
if (rc != Success)
return rc;
VERIFY_SHMPTR(stuff->shmseg, stuff->offset, TRUE, shmdesc, client);
width = stuff->width;
height = stuff->height;
depth = stuff->depth;
if (!width || !height || !depth)
{
client->errorValue = 0;
return BadValue;
}
if (width > 32767 || height > 32767)
return BadAlloc;
if (stuff->depth != 1)
{
pDepth = pDraw->pScreen->allowedDepths;
for (i=0; i<pDraw->pScreen->numDepths; i++, pDepth++)
if (pDepth->depth == stuff->depth)
goto CreatePmap;
client->errorValue = stuff->depth;
return BadValue;
}
CreatePmap:
size = PixmapBytePad(width, depth) * height;
if (sizeof(size) == 4 && BitsPerPixel(depth) > 8) {
if (size < width * height)
return BadAlloc;
}
/* thankfully, offset is unsigned */
if (stuff->offset + size < size)
return BadAlloc;
VERIFY_SHMSIZE(shmdesc, stuff->offset, size, client);
if(!(newPix = malloc(sizeof(PanoramiXRes))))
return BadAlloc;
newPix->type = XRT_PIXMAP;
newPix->u.pix.shared = TRUE;
newPix->info[0].id = stuff->pid;
for(j = 1; j < PanoramiXNumScreens; j++)
newPix->info[j].id = FakeClientID(client->index);
result = Success;
FOR_NSCREENS(j) {
ShmScrPrivateRec *screen_priv;
pScreen = screenInfo.screens[j];
screen_priv = ShmGetScreenPriv(pScreen);
pMap = (*screen_priv->shmFuncs->CreatePixmap)(pScreen,
stuff->width, stuff->height, stuff->depth,
shmdesc->addr + stuff->offset);
if (pMap) {
dixSetPrivate(&pMap->devPrivates, shmPixmapPrivateKey, shmdesc);
shmdesc->refcnt++;
pMap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
pMap->drawable.id = newPix->info[j].id;
if (!AddResource(newPix->info[j].id, RT_PIXMAP, (pointer)pMap)) {
(*pScreen->DestroyPixmap)(pMap);
result = BadAlloc;
break;
}
} else {
result = BadAlloc;
break;
}
}
if(result == BadAlloc) {
while(j--) {
(*pScreen->DestroyPixmap)(pMap);
FreeResource(newPix->info[j].id, RT_NONE);
}
free(newPix);
} else
AddResource(stuff->pid, XRT_PIXMAP, newPix);
return result;
}
static int
ProcRRSelectInput (ClientPtr client)
{
REQUEST(xRRSelectInputReq);
rrClientPriv(client);
RRTimesPtr pTimes;
WindowPtr pWin;
RREventPtr pRREvent, *pHead;
XID clientResource;
int rc;
REQUEST_SIZE_MATCH(xRRSelectInputReq);
rc = dixLookupWindow(&pWin, stuff->window, client, DixReceiveAccess);
if (rc != Success)
return rc;
rc = dixLookupResourceByType((pointer *)&pHead, pWin->drawable.id,
RREventType, client, DixWriteAccess);
if (rc != Success && rc != BadValue)
return rc;
if (stuff->enable & (RRScreenChangeNotifyMask|
RRCrtcChangeNotifyMask|
RROutputChangeNotifyMask|
RROutputPropertyNotifyMask))
{
ScreenPtr pScreen = pWin->drawable.pScreen;
rrScrPriv (pScreen);
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, (pointer)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, (pointer)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
{
client->errorValue = stuff->enable;
return BadValue;
}
return Success;
}
void
__glXScreenInit(GLint numscreens)
{
int s;
int c;
DMXScreenInfo *dmxScreen0 = &dmxScreens[0];
__glXNumActiveScreens = numscreens;
CalcServerVersionAndExtensions();
__glXFBConfigs = NULL;
__glXNumFBConfigs = 0;
if ((__glXVersionMajor == 1 && __glXVersionMinor >= 3) ||
(__glXVersionMajor > 1) ||
(strstr(ExtensionsString, "GLX_SGIX_fbconfig"))) {
/*
// Initialize FBConfig info.
// find the set of FBConfigs that are present on all back-end
// servers - only those configs will be supported
*/
__glXFBConfigs = (__GLXFBConfig **) malloc(dmxScreen0->numFBConfigs *
(numscreens +
1) *
sizeof(__GLXFBConfig *));
__glXNumFBConfigs = 0;
for (c = 0; c < dmxScreen0->numFBConfigs; c++) {
__GLXFBConfig *cfg = NULL;
if (numscreens > 1) {
for (s = 1; s < numscreens; s++) {
DMXScreenInfo *dmxScreen = &dmxScreens[s];
cfg = FindMatchingFBConfig(&dmxScreen0->fbconfigs[c],
dmxScreen->fbconfigs,
dmxScreen->numFBConfigs);
__glXFBConfigs[__glXNumFBConfigs * (numscreens + 1) + s +
1] = cfg;
if (!cfg) {
dmxLog(dmxInfo,
"screen0 FBConfig 0x%x is missing on screen#%d\n",
dmxScreen0->fbconfigs[c].id, s);
break;
}
else {
dmxLog(dmxInfo,
"screen0 FBConfig 0x%x matched to 0x%x on screen#%d\n",
dmxScreen0->fbconfigs[c].id, cfg->id, s);
}
}
}
else {
cfg = &dmxScreen0->fbconfigs[c];
}
if (cfg) {
/* filter out overlay visuals */
if (cfg->level == 0) {
__GLXFBConfig *proxy_cfg;
__glXFBConfigs[__glXNumFBConfigs * (numscreens + 1) + 1] =
&dmxScreen0->fbconfigs[c];
proxy_cfg = malloc(sizeof(__GLXFBConfig));
memcpy(proxy_cfg, cfg, sizeof(__GLXFBConfig));
proxy_cfg->id = FakeClientID(0);
/* visual will be associated later in __glXGetFBConfigs */
proxy_cfg->associatedVisualId = (unsigned int) -1;
__glXFBConfigs[__glXNumFBConfigs * (numscreens + 1) + 0] =
proxy_cfg;
__glXNumFBConfigs++;
}
}
}
}
}
Bool
winFinishScreenInitNativeGDI (int index,
ScreenPtr pScreen,
int argc, char **argv)
{
winScreenPriv(pScreen);
winScreenInfoPtr pScreenInfo = &g_ScreenInfo[index];
VisualPtr pVisuals = NULL;
DepthPtr pDepths = NULL;
VisualID rootVisual = 0;
int nVisuals = 0, nDepths = 0, nRootDepth = 0;
/* Ignore user input (mouse, keyboard) */
pScreenInfo->fIgnoreInput = FALSE;
/* Get device contexts for the screen and shadow bitmap */
pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
if (pScreenPriv->hdcScreen == NULL)
FatalError ("winFinishScreenInitNativeGDI - Couldn't get a DC\n");
/* Init visuals */
if (!(*pScreenPriv->pwinInitVisuals) (pScreen))
{
ErrorF ("winFinishScreenInitNativeGDI - pwinInitVisuals failed\n");
return FALSE;
}
/* Initialize the mi visuals */
if (!miInitVisuals (&pVisuals, &pDepths, &nVisuals, &nDepths, &nRootDepth,
&rootVisual,
((unsigned long)1 << (pScreenInfo->dwDepth - 1)), 8,
TrueColor))
{
ErrorF ("winFinishScreenInitNativeGDI - miInitVisuals () failed\n");
return FALSE;
}
/* Initialize the CloseScreen procedure pointer */
pScreen->CloseScreen = NULL;
/* Initialize the mi code */
if (!miScreenInit (pScreen,
NULL, /* No framebuffer */
pScreenInfo->dwWidth, pScreenInfo->dwHeight,
monitorResolution, monitorResolution,
pScreenInfo->dwStride,
nRootDepth, nDepths, pDepths, rootVisual,
nVisuals, pVisuals))
{
ErrorF ("winFinishScreenInitNativeGDI - miScreenInit failed\n");
return FALSE;
}
pScreen->defColormap = FakeClientID(0);
/*
* Register our block and wakeup handlers; these procedures
* process messages in our Windows message queue; specifically,
* they process mouse and keyboard input.
*/
pScreen->BlockHandler = winBlockHandler;
pScreen->WakeupHandler = winWakeupHandler;
pScreen->blockData = pScreen;
pScreen->wakeupData = pScreen;
/* Place our save screen function */
pScreen->SaveScreen = winSaveScreen;
/* Pixmaps */
pScreen->CreatePixmap = winCreatePixmapNativeGDI;
pScreen->DestroyPixmap = winDestroyPixmapNativeGDI;
/* Other Screen Routines */
pScreen->QueryBestSize = winQueryBestSizeNativeGDI;
pScreen->SaveScreen = winSaveScreen;
pScreen->GetImage = miGetImage;
pScreen->GetSpans = winGetSpansNativeGDI;
/* Window Procedures */
pScreen->CreateWindow = winCreateWindowNativeGDI;
pScreen->DestroyWindow = winDestroyWindowNativeGDI;
pScreen->PositionWindow = winPositionWindowNativeGDI;
/*pScreen->ChangeWindowAttributes = winChangeWindowAttributesNativeGDI;*/
pScreen->RealizeWindow = winMapWindowNativeGDI;
pScreen->UnrealizeWindow = winUnmapWindowNativeGDI;
/* Paint window */
pScreen->CopyWindow = winCopyWindowNativeGDI;
/* Fonts */
pScreen->RealizeFont = winRealizeFontNativeGDI;
pScreen->UnrealizeFont = winUnrealizeFontNativeGDI;
/* GC */
pScreen->CreateGC = winCreateGCNativeGDI;
/* Colormap Routines */
pScreen->CreateColormap = miInitializeColormap;
pScreen->DestroyColormap = (DestroyColormapProcPtr) (void (*)(void)) NoopDDA;
pScreen->InstallColormap = miInstallColormap;
pScreen->UninstallColormap = miUninstallColormap;
pScreen->ListInstalledColormaps = miListInstalledColormaps;
pScreen->StoreColors = (StoreColorsProcPtr) (void (*)(void)) NoopDDA;
pScreen->ResolveColor = miResolveColor;
/* Bitmap */
pScreen->BitmapToRegion = winPixmapToRegionNativeGDI;
ErrorF ("winFinishScreenInitNativeGDI - calling miDCInitialize\n");
/* Set the default white and black pixel positions */
pScreen->whitePixel = pScreen->blackPixel = (Pixel) 0;
/* Initialize the cursor */
if (!miDCInitialize (pScreen, &g_winPointerCursorFuncs))
{
ErrorF ("winFinishScreenInitNativeGDI - miDCInitialize failed\n");
return FALSE;
}
/* Create a default colormap */
if (!miCreateDefColormap (pScreen))
{
ErrorF ("winFinishScreenInitNativeGDI - miCreateDefColormap () "
"failed\n");
return FALSE;
}
ErrorF ("winFinishScreenInitNativeGDI - miCreateDefColormap () "
"returned\n");
/* mi doesn't use a CloseScreen procedure, so no need to wrap */
pScreen->CloseScreen = pScreenPriv->pwinCloseScreen;
/* Tell the server that we are enabled */
pScreenPriv->fEnabled = TRUE;
ErrorF ("winFinishScreenInitNativeGDI - Successful addition of "
"screen %08x\n",
(unsigned int) pScreen);
return TRUE;
}
static int
XFixesSelectSelectionInput (ClientPtr pClient,
Atom selection,
WindowPtr pWindow,
CARD32 eventMask)
{
SelectionEventPtr *prev, e;
for (prev = &selectionEvents; (e = *prev); prev = &e->next)
{
if (e->selection == selection &&
e->pClient == pClient &&
e->pWindow == pWindow)
{
break;
}
}
if (!eventMask)
{
if (e)
{
FreeResource (e->clientResource, 0);
}
return Success;
}
if (!e)
{
e = (SelectionEventPtr) xalloc (sizeof (SelectionEventRec));
if (!e)
return BadAlloc;
e->next = 0;
e->selection = selection;
e->pClient = pClient;
e->pWindow = pWindow;
e->clientResource = FakeClientID(pClient->index);
/*
* Add a resource hanging from the window to
* catch window destroy
*/
if (!LookupIDByType(pWindow->drawable.id, SelectionWindowType))
if (!AddResource (pWindow->drawable.id, SelectionWindowType,
(pointer) pWindow))
{
xfree (e);
return BadAlloc;
}
if (!AddResource (e->clientResource, SelectionClientType, (pointer) e))
return BadAlloc;
*prev = e;
if (!CheckSelectionCallback ())
{
FreeResource (e->clientResource, 0);
return BadAlloc;
}
}
e->eventMask = eventMask;
return Success;
}
static int
XFixesSelectSelectionInput(ClientPtr pClient,
Atom selection, WindowPtr pWindow, CARD32 eventMask)
{
pointer val;
int rc;
SelectionEventPtr *prev, e;
rc = XaceHook(XACE_SELECTION_ACCESS, pClient, selection, DixGetAttrAccess);
if (rc != Success)
return rc;
for (prev = &selectionEvents; (e = *prev); prev = &e->next) {
if (e->selection == selection &&
e->pClient == pClient && e->pWindow == pWindow) {
break;
}
}
if (!eventMask) {
if (e) {
FreeResource(e->clientResource, 0);
}
return Success;
}
if (!e) {
e = (SelectionEventPtr) malloc(sizeof(SelectionEventRec));
if (!e)
return BadAlloc;
e->next = 0;
e->selection = selection;
e->pClient = pClient;
e->pWindow = pWindow;
e->clientResource = FakeClientID(pClient->index);
/*
* Add a resource hanging from the window to
* catch window destroy
*/
rc = dixLookupResourceByType(&val, pWindow->drawable.id,
SelectionWindowType, serverClient,
DixGetAttrAccess);
if (rc != Success)
if (!AddResource(pWindow->drawable.id, SelectionWindowType,
(pointer) pWindow)) {
free(e);
return BadAlloc;
}
if (!AddResource(e->clientResource, SelectionClientType, (pointer) e))
return BadAlloc;
*prev = e;
if (!CheckSelectionCallback()) {
FreeResource(e->clientResource, 0);
return BadAlloc;
}
}
e->eventMask = eventMask;
return Success;
}
/* dts * (inch/dot) * (25.4 mm / inch) = mm */
Bool
afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, int dpix, int dpiy, int width)
/* pointer to screen bitmap */
/* in pixels */
/* dots per inch */
/* pixel width of frame buffer */
{
VisualPtr visuals;
DepthPtr depths;
int nvisuals;
int ndepths;
int rootdepth;
VisualID defaultVisual;
pointer oldDevPrivate;
rootdepth = 0;
if (!afbInitVisuals(&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
&defaultVisual, 256, 8)) {
ErrorF("afbInitVisuals: FALSE\n");
return FALSE;
}
if (!afbAllocatePrivates(pScreen,(int *)NULL, (int *)NULL)) {
ErrorF("afbAllocatePrivates: FALSE\n");
return FALSE;
}
pScreen->defColormap = (Colormap)FakeClientID(0);
/* whitePixel, blackPixel */
pScreen->blackPixel = 0;
pScreen->whitePixel = 0;
pScreen->QueryBestSize = afbQueryBestSize;
/* SaveScreen */
pScreen->GetImage = afbGetImage;
pScreen->GetSpans = afbGetSpans;
pScreen->CreateWindow = afbCreateWindow;
pScreen->DestroyWindow = afbDestroyWindow;
pScreen->PositionWindow = afbPositionWindow;
pScreen->ChangeWindowAttributes = afbChangeWindowAttributes;
pScreen->RealizeWindow = afbMapWindow;
pScreen->UnrealizeWindow = afbUnmapWindow;
pScreen->PaintWindowBackground = afbPaintWindow;
pScreen->PaintWindowBorder = afbPaintWindow;
pScreen->CopyWindow = afbCopyWindow;
pScreen->CreatePixmap = afbCreatePixmap;
pScreen->DestroyPixmap = afbDestroyPixmap;
pScreen->RealizeFont = afbRealizeFont;
pScreen->UnrealizeFont = afbUnrealizeFont;
pScreen->CreateGC = afbCreateGC;
pScreen->CreateColormap = afbInitializeColormap;
pScreen->DestroyColormap = (DestroyColormapProcPtr)NoopDDA;
pScreen->InstallColormap = afbInstallColormap;
pScreen->UninstallColormap = afbUninstallColormap;
pScreen->ListInstalledColormaps = afbListInstalledColormaps;
pScreen->StoreColors = (StoreColorsProcPtr)NoopDDA;
pScreen->ResolveColor = afbResolveColor;
pScreen->BitmapToRegion = afbPixmapToRegion;
oldDevPrivate = pScreen->devPrivate;
if (!miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width, rootdepth,
ndepths, depths, defaultVisual, nvisuals, visuals)) {
ErrorF("miScreenInit: FALSE\n");
return FALSE;
}
pScreen->CloseScreen = afbCloseScreen;
pScreen->CreateScreenResources = afbCreateScreenResources;
pScreen->BackingStoreFuncs = afbBSFuncRec;
pScreen->devPrivates[afbScreenPrivateIndex].ptr = pScreen->devPrivate;
pScreen->devPrivate = oldDevPrivate;
return TRUE;
}
int
compRedirectSubwindows (ClientPtr pClient, WindowPtr pWin, int update)
{
CompSubwindowsPtr csw = GetCompSubwindows (pWin);
CompClientWindowPtr ccw;
WindowPtr pChild;
/*
* Only one Manual update is allowed
*/
if (csw && update == CompositeRedirectManual)
for (ccw = csw->clients; ccw; ccw = ccw->next)
if (ccw->update == CompositeRedirectManual)
return BadAccess;
/*
* Allocate per-client per-window structure
* The client *could* allocate multiple, but while supported,
* it is not expected to be common
*/
ccw = malloc(sizeof (CompClientWindowRec));
if (!ccw)
return BadAlloc;
ccw->id = FakeClientID (pClient->index);
ccw->update = update;
/*
* Now make sure there's a per-window structure to hang this from
*/
if (!csw)
{
csw = malloc(sizeof (CompSubwindowsRec));
if (!csw)
{
free(ccw);
return BadAlloc;
}
csw->update = CompositeRedirectAutomatic;
csw->clients = 0;
dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, csw);
}
/*
* Redirect all existing windows
*/
for (pChild = pWin->lastChild; pChild; pChild = pChild->prevSib)
{
int ret = compRedirectWindow (pClient, pChild, update);
if (ret != Success)
{
for (pChild = pChild->nextSib; pChild; pChild = pChild->nextSib)
(void) compUnredirectWindow (pClient, pChild, update);
if (!csw->clients)
{
free(csw);
dixSetPrivate(&pWin->devPrivates, CompSubwindowsPrivateKey, 0);
}
free(ccw);
return ret;
}
}
/*
* Hook into subwindows list
*/
ccw->next = csw->clients;
csw->clients = ccw;
if (!AddResource (ccw->id, CompositeClientSubwindowsType, pWin))
return BadAlloc;
if (ccw->update == CompositeRedirectManual)
{
csw->update = CompositeRedirectManual;
/*
* tell damage extension that damage events for this client are
* critical output
*/
DamageExtSetCritical (pClient, TRUE);
}
return Success;
}
/*
* Redirect one window for one client
*/
int
compRedirectWindow (ClientPtr pClient, WindowPtr pWin, int update)
{
CompWindowPtr cw = GetCompWindow (pWin);
CompClientWindowPtr ccw;
Bool wasMapped = pWin->mapped;
CompScreenPtr cs = GetCompScreen(pWin->drawable.pScreen);
if (pWin == cs->pOverlayWin) {
return Success;
}
if (!pWin->parent)
return BadMatch;
/*
* Only one Manual update is allowed
*/
if (cw && update == CompositeRedirectManual)
for (ccw = cw->clients; ccw; ccw = ccw->next)
if (ccw->update == CompositeRedirectManual)
return BadAccess;
/*
* Allocate per-client per-window structure
* The client *could* allocate multiple, but while supported,
* it is not expected to be common
*/
ccw = malloc(sizeof (CompClientWindowRec));
if (!ccw)
return BadAlloc;
ccw->id = FakeClientID (pClient->index);
ccw->update = update;
/*
* Now make sure there's a per-window structure to hang this from
*/
if (!cw)
{
cw = malloc(sizeof (CompWindowRec));
if (!cw)
{
free(ccw);
return BadAlloc;
}
cw->damage = DamageCreate (compReportDamage,
compDestroyDamage,
DamageReportNonEmpty,
FALSE,
pWin->drawable.pScreen,
pWin);
if (!cw->damage)
{
free(ccw);
free(cw);
return BadAlloc;
}
if (wasMapped)
{
DisableMapUnmapEvents (pWin);
UnmapWindow (pWin, FALSE);
EnableMapUnmapEvents (pWin);
}
RegionNull(&cw->borderClip);
cw->borderClipX = 0;
cw->borderClipY = 0;
cw->update = CompositeRedirectAutomatic;
cw->clients = 0;
cw->oldx = COMP_ORIGIN_INVALID;
cw->oldy = COMP_ORIGIN_INVALID;
cw->damageRegistered = FALSE;
cw->damaged = FALSE;
cw->pOldPixmap = NullPixmap;
dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, cw);
}
ccw->next = cw->clients;
cw->clients = ccw;
if (!AddResource (ccw->id, CompositeClientWindowType, pWin))
return BadAlloc;
if (ccw->update == CompositeRedirectManual)
{
/* If the window was CompositeRedirectAutomatic, then
* unmap the window so that the parent clip list will
* be correctly recomputed.
*/
if (pWin->mapped)
{
DisableMapUnmapEvents (pWin);
UnmapWindow (pWin, FALSE);
EnableMapUnmapEvents (pWin);
}
if (cw->damageRegistered)
{
DamageUnregister (&pWin->drawable, cw->damage);
cw->damageRegistered = FALSE;
}
cw->update = CompositeRedirectManual;
}
if (!compCheckRedirect (pWin))
{
FreeResource (ccw->id, RT_NONE);
return BadAlloc;
}
if (wasMapped && !pWin->mapped)
{
Bool overrideRedirect = pWin->overrideRedirect;
pWin->overrideRedirect = TRUE;
DisableMapUnmapEvents (pWin);
MapWindow (pWin, pClient);
EnableMapUnmapEvents (pWin);
pWin->overrideRedirect = overrideRedirect;
}
return Success;
}
static int
ProcWindowsWMSelectInput(ClientPtr client)
{
REQUEST(xWindowsWMSelectInputReq);
WMEventPtr pEvent, pNewEvent, *pHead;
XID clientResource;
REQUEST_SIZE_MATCH(xWindowsWMSelectInputReq);
dixLookupResourceByType((void *) &pHead, eventResource, eventResourceType,
client, DixWriteAccess);
if (stuff->mask != 0) {
if (pHead) {
/* check for existing entry. */
for (pEvent = *pHead; pEvent; pEvent = pEvent->next) {
if (pEvent->client == client) {
pEvent->mask = stuff->mask;
updateEventMask(pHead);
return Success;
}
}
}
/* build the entry */
pNewEvent = (WMEventPtr) malloc(sizeof(WMEventRec));
if (!pNewEvent)
return BadAlloc;
pNewEvent->next = 0;
pNewEvent->client = client;
pNewEvent->mask = stuff->mask;
/*
* add a resource that will be deleted when
* the client goes away
*/
clientResource = FakeClientID(client->index);
pNewEvent->clientResource = clientResource;
if (!AddResource(clientResource, ClientType, (void *) pNewEvent))
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 = (WMEventPtr *) malloc(sizeof(WMEventPtr));
if (!pHead ||
!AddResource(eventResource, eventResourceType, (void *) pHead))
{
FreeResource(clientResource, RT_NONE);
return BadAlloc;
}
*pHead = 0;
}
pNewEvent->next = *pHead;
*pHead = pNewEvent;
updateEventMask(pHead);
}
else if (stuff->mask == 0) {
/* delete the interest */
if (pHead) {
pNewEvent = 0;
for (pEvent = *pHead; pEvent; pEvent = pEvent->next) {
if (pEvent->client == client)
break;
pNewEvent = pEvent;
}
if (pEvent) {
FreeResource(pEvent->clientResource, ClientType);
if (pNewEvent)
pNewEvent->next = pEvent->next;
else
*pHead = pEvent->next;
free(pEvent);
updateEventMask(pHead);
}
}
}
else {
client->errorValue = stuff->mask;
return BadValue;
}
return Success;
}
int
XvdiSelectVideoNotify(
ClientPtr client,
DrawablePtr pDraw,
BOOL onoff
){
XvVideoNotifyPtr pn,tpn,fpn;
int rc;
/* FIND VideoNotify LIST */
rc = dixLookupResourceByType((pointer *)&pn, pDraw->id, XvRTVideoNotifyList,
client, DixWriteAccess);
if (rc != Success && rc != BadValue)
return rc;
/* IF ONE DONES'T EXIST AND NO MASK, THEN JUST RETURN */
if (!onoff && !pn) return Success;
/* IF ONE DOESN'T EXIST CREATE IT AND ADD A RESOURCE SO THAT THE LIST
WILL BE DELETED WHEN THE DRAWABLE IS DESTROYED */
if (!pn)
{
if (!(tpn = xalloc(sizeof(XvVideoNotifyRec))))
return BadAlloc;
tpn->next = NULL;
if (!AddResource(pDraw->id, XvRTVideoNotifyList, tpn))
{
xfree(tpn);
return BadAlloc;
}
}
else
{
/* LOOK TO SEE IF ENTRY ALREADY EXISTS */
fpn = NULL;
tpn = pn;
while (tpn)
{
if (tpn->client == client)
{
if (!onoff) tpn->client = NULL;
return Success;
}
if (!tpn->client) fpn = tpn; /* TAKE NOTE OF FREE ENTRY */
tpn = tpn->next;
}
/* IF TUNNING OFF, THEN JUST RETURN */
if (!onoff) return Success;
/* IF ONE ISN'T FOUND THEN ALLOCATE ONE AND LINK IT INTO THE LIST */
if (fpn)
{
tpn = fpn;
}
else
{
if (!(tpn = xalloc(sizeof(XvVideoNotifyRec))))
return BadAlloc;
tpn->next = pn->next;
pn->next = tpn;
}
}
/* INIT CLIENT PTR IN CASE WE CAN'T ADD RESOURCE */
/* ADD RESOURCE SO THAT IF CLIENT EXITS THE CLIENT PTR WILL BE CLEARED */
tpn->client = NULL;
tpn->id = FakeClientID(client->index);
AddResource(tpn->id, XvRTVideoNotify, tpn);
tpn->client = client;
return Success;
}
/*
* Redirect one window for one client
*/
int
compRedirectWindow(ClientPtr pClient, WindowPtr pWin, int update)
{
CompWindowPtr cw = GetCompWindow(pWin);
CompClientWindowPtr ccw;
CompScreenPtr cs = GetCompScreen(pWin->drawable.pScreen);
WindowPtr pLayerWin = NULL;
Bool anyMarked = FALSE;
if (pWin == cs->pOverlayWin) {
return Success;
}
if (!pWin->parent)
return BadMatch;
/*
* Only one Manual update is allowed
*/
if (cw && update == CompositeRedirectManual)
for (ccw = cw->clients; ccw; ccw = ccw->next)
if (ccw->update == CompositeRedirectManual)
return BadAccess;
/*
* Allocate per-client per-window structure
* The client *could* allocate multiple, but while supported,
* it is not expected to be common
*/
ccw = malloc(sizeof(CompClientWindowRec));
if (!ccw)
return BadAlloc;
ccw->id = FakeClientID(pClient->index);
ccw->update = update;
/*
* Now make sure there's a per-window structure to hang this from
*/
if (!cw) {
cw = malloc(sizeof(CompWindowRec));
if (!cw) {
free(ccw);
return BadAlloc;
}
cw->damage = DamageCreate(compReportDamage,
compDestroyDamage,
DamageReportNonEmpty,
FALSE, pWin->drawable.pScreen, pWin);
if (!cw->damage) {
free(ccw);
free(cw);
return BadAlloc;
}
anyMarked = compMarkWindows(pWin, &pLayerWin);
RegionNull(&cw->borderClip);
cw->update = CompositeRedirectAutomatic;
cw->clients = 0;
cw->oldx = COMP_ORIGIN_INVALID;
cw->oldy = COMP_ORIGIN_INVALID;
cw->damageRegistered = FALSE;
cw->damaged = FALSE;
cw->pOldPixmap = NullPixmap;
dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, cw);
}
ccw->next = cw->clients;
cw->clients = ccw;
if (!AddResource(ccw->id, CompositeClientWindowType, pWin))
return BadAlloc;
if (ccw->update == CompositeRedirectManual) {
if (!anyMarked)
anyMarked = compMarkWindows(pWin, &pLayerWin);
if (cw->damageRegistered) {
DamageUnregister(&pWin->drawable, cw->damage);
cw->damageRegistered = FALSE;
}
cw->update = CompositeRedirectManual;
}
else if (cw->update == CompositeRedirectAutomatic && !cw->damageRegistered) {
if (!anyMarked)
anyMarked = compMarkWindows(pWin, &pLayerWin);
}
if (!compCheckRedirect(pWin)) {
FreeResource(ccw->id, RT_NONE);
return BadAlloc;
}
if (anyMarked)
compHandleMarkedWindows(pWin, pLayerWin);
return Success;
}
