/* ** 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; }