Bool rdpRRScreenSetSize(ScreenPtr pScreen, CARD16 width, CARD16 height, CARD32 mmWidth, CARD32 mmHeight) { WindowPtr root; PixmapPtr screenPixmap; BoxRec box; rdpPtr dev; LLOGLN(0, ("rdpRRScreenSetSize: width %d height %d mmWidth %d mmHeight %d", width, height, (int)mmWidth, (int)mmHeight)); dev = rdpGetDevFromScreen(pScreen); root = rdpGetRootWindowPtr(pScreen); if ((width < 1) || (height < 1)) { LLOGLN(10, (" error width %d height %d", width, height)); return FALSE; } dev->width = width; dev->height = height; dev->paddedWidthInBytes = PixmapBytePad(dev->width, dev->depth); dev->sizeInBytes = dev->paddedWidthInBytes * dev->height; pScreen->width = width; pScreen->height = height; pScreen->mmWidth = mmWidth; pScreen->mmHeight = mmHeight; screenPixmap = pScreen->GetScreenPixmap(pScreen); g_free(dev->pfbMemory_alloc); dev->pfbMemory_alloc = (char *) g_malloc(dev->sizeInBytes + 16, 1); dev->pfbMemory = (char *) RDPALIGN(dev->pfbMemory_alloc, 16); if (screenPixmap != 0) { pScreen->ModifyPixmapHeader(screenPixmap, width, height, -1, -1, dev->paddedWidthInBytes, dev->pfbMemory); } box.x1 = 0; box.y1 = 0; box.x2 = width; box.y2 = height; rdpRegionInit(&root->winSize, &box, 1); rdpRegionInit(&root->borderSize, &box, 1); rdpRegionReset(&root->borderClip, &box); rdpRegionBreak(&root->clipList); root->drawable.width = width; root->drawable.height = height; ResizeChildrenWinSize(root, 0, 0, 0, 0); RRGetInfo(pScreen, 1); LLOGLN(0, (" screen resized to %dx%d", pScreen->width, pScreen->height)); RRScreenSizeNotify(pScreen); #if XORG_VERSION_CURRENT < XORG_VERSION_NUMERIC(1, 13, 0, 0, 0) xf86EnableDisableFBAccess(pScreen->myNum, FALSE); xf86EnableDisableFBAccess(pScreen->myNum, TRUE); #else xf86EnableDisableFBAccess(xf86Screens[pScreen->myNum], FALSE); xf86EnableDisableFBAccess(xf86Screens[pScreen->myNum], TRUE); #endif return TRUE; }
static void RootlessPaintWindowBackground(WindowPtr pWin, RegionPtr pRegion, int what) { int oldBackgroundState = 0; PixUnion oldBackground; ScreenPtr pScreen = pWin->drawable.pScreen; SCREEN_UNWRAP(pScreen, PaintWindowBackground); RL_DEBUG_MSG("paintwindowbackground start (win 0x%x) ", pWin); if (IsFramedWindow(pWin)) { if (IsRoot(pWin)) { // set root background to magic transparent color oldBackgroundState = pWin->backgroundState; oldBackground = pWin->background; pWin->backgroundState = BackgroundPixel; pWin->background.pixel = 0x00fffffe; } } pScreen->PaintWindowBackground(pWin, pRegion, what); if (IsFramedWindow(pWin)) { RootlessDamageRegion(pWin, pRegion); if (IsRoot(pWin)) { pWin->backgroundState = oldBackgroundState; pWin->background = oldBackground; } } SCREEN_WRAP(pScreen, PaintWindowBackground); RL_DEBUG_MSG("paintwindowbackground end\n"); }
/** Create a graphics context on the back-end server associated /a pGC's * screen. */ Bool dmxCreateGC(GCPtr pGC) { ScreenPtr pScreen = pGC->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); Bool ret; DMX_UNWRAP(CreateGC, dmxScreen, pScreen); if ((ret = pScreen->CreateGC(pGC))) { /* Save the old funcs */ pGCPriv->funcs = pGC->funcs; pGCPriv->ops = NULL; pGC->funcs = &dmxGCFuncs; if (dmxScreen->beDisplay) { dmxBECreateGC(pScreen, pGC); } else { pGCPriv->gc = NULL; } /* Check for "magic special case" * 1. see CreateGC in dix/gc.c for more info * 2. see dmxChangeGC for more info */ pGCPriv->msc = (!pGC->tileIsPixel && !pGC->tile.pixmap); } DMX_WRAP(CreateGC, dmxCreateGC, dmxScreen, pScreen); return ret; }
static DRI2Buffer2Ptr vivante_dri2_CreateBuffer(DrawablePtr drawable, unsigned int attachment, unsigned int format) { struct vivante_dri2_buffer *buf; struct vivante_pixmap *vpix; ScreenPtr pScreen = drawable->pScreen; PixmapPtr pixmap = NULL; uint32_t name; fprintf(stderr, "%s: %p %u %u\n", __func__, drawable, attachment, format); if (attachment == DRI2BufferFrontLeft) { pixmap = vivante_dri2_get_front_pixmap(drawable); if (!pixmap) { drawable = &pixmap->drawable; pixmap = NULL; } } if (pixmap == NULL) { int width = drawable->width; int height = drawable->height; int depth = format ? format : drawable->depth; pixmap = pScreen->CreatePixmap(pScreen, width, height, depth, 0); if (!pixmap) goto err; } vpix = vivante_get_pixmap_priv(pixmap); if (!vpix) goto err; buf = calloc(1, sizeof *buf); if (!buf) goto err; if (!vpix->bo || drm_armada_bo_flink(vpix->bo, &name)) { free(buf); goto err; } buf->dri2.attachment = attachment; buf->dri2.name = name; buf->dri2.pitch = pixmap->devKind; buf->dri2.cpp = pixmap->drawable.bitsPerPixel / 8; buf->dri2.flags = 0; buf->dri2.format = format; buf->dri2.driverPrivate = buf; buf->pixmap = pixmap; buf->ref = 1; return &buf->dri2; err: if (pixmap) pScreen->DestroyPixmap(pixmap); return NULL; }
Bool rdpRRScreenSetSize(ScreenPtr pScreen, CARD16 width, CARD16 height, CARD32 mmWidth, CARD32 mmHeight) { PixmapPtr screenPixmap; BoxRec box; ErrorF("rdpRRScreenSetSize: width %d height %d mmWidth %d mmHeight %d\n", width, height, (int)mmWidth, (int)mmHeight); if ((width < 1) || (height < 1)) { ErrorF(" error width %d height %d\n", width, height); return FALSE; } g_rdpScreen.width = width; g_rdpScreen.height = height; g_rdpScreen.paddedWidthInBytes = PixmapBytePad(g_rdpScreen.width, g_rdpScreen.depth); g_rdpScreen.sizeInBytes = g_rdpScreen.paddedWidthInBytes * g_rdpScreen.height; pScreen->width = width; pScreen->height = height; pScreen->mmWidth = mmWidth; pScreen->mmHeight = mmHeight; screenPixmap = pScreen->GetScreenPixmap(pScreen); if (screenPixmap != 0) { ErrorF(" resizing screenPixmap [%p] to %dx%d, currently at %dx%d\n", (void *)screenPixmap, width, height, screenPixmap->drawable.width, screenPixmap->drawable.height); pScreen->ModifyPixmapHeader(screenPixmap, width, height, g_rdpScreen.depth, g_rdpScreen.bitsPerPixel, g_rdpScreen.paddedWidthInBytes, g_rdpScreen.pfbMemory); ErrorF(" pixmap resized to %dx%d\n", screenPixmap->drawable.width, screenPixmap->drawable.height); } DEBUG_OUT((" root window %p\n", (void *)pScreen->root)); box.x1 = 0; box.y1 = 0; box.x2 = width; box.y2 = height; RegionInit(&pScreen->root->winSize, &box, 1); RegionInit(&pScreen->root->borderSize, &box, 1); RegionReset(&pScreen->root->borderClip, &box); RegionBreak(&pScreen->root->clipList); pScreen->root->drawable.width = width; pScreen->root->drawable.height = height; ResizeChildrenWinSize(pScreen->root, 0, 0, 0, 0); RRGetInfo(pScreen, 1); rdpInvalidateArea(g_pScreen, 0, 0, g_rdpScreen.width, g_rdpScreen.height); ErrorF(" screen resized to %dx%d\n", pScreen->width, pScreen->height); return TRUE; }
static Bool glamor_egl_close_screen(ScreenPtr screen) { ScrnInfoPtr scrn; struct glamor_egl_screen_private *glamor_egl; PixmapPtr screen_pixmap; EGLImageKHR back_image; scrn = xf86ScreenToScrn(screen); glamor_egl = glamor_egl_get_screen_private(scrn); screen_pixmap = screen->GetScreenPixmap(screen); eglDestroyImageKHR(glamor_egl->display,glamor_egl->front_image); dixSetPrivate(&screen_pixmap->devPrivates, glamor_egl_pixmap_private_key, NULL); glamor_egl->front_image = NULL; if (glamor_egl->back_pixmap && *glamor_egl->back_pixmap) { back_image = dixLookupPrivate(&(*glamor_egl->back_pixmap)->devPrivates, glamor_egl_pixmap_private_key); if (back_image != NULL && back_image != EGL_NO_IMAGE_KHR) { eglDestroyImageKHR(glamor_egl->display, back_image); dixSetPrivate(&(*glamor_egl->back_pixmap)->devPrivates, glamor_egl_pixmap_private_key, NULL); } } screen->CloseScreen = glamor_egl->saved_close_screen; return screen->CloseScreen(screen); }
void glWinCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc) { ScreenPtr pScreen = pWindow->drawable.pScreen; glWinScreenRec *screenPriv = &glWinScreens[pScreen->myNum]; __GLXdrawablePrivate *glxPriv; /* Check if the window is attached and discard any drawing request */ glxPriv = __glXFindDrawablePrivate(pWindow->drawable.id); if (glxPriv) { __GLXcontext *gx; /* GL contexts bound to this window for drawing */ for (gx = glxPriv->drawGlxc; gx != NULL; gx = gx->next) { /* GLWIN_DEBUG_MSG("glWinCopyWindow - calling glDrawBuffer\n"); glDrawBuffer(GL_FRONT); */ return; } /* GL contexts bound to this window for reading */ for (gx = glxPriv->readGlxc; gx != NULL; gx = gx->next) { return; } } GLWIN_DEBUG_MSG("glWinCopyWindow - passing to hw layer\n"); pScreen->CopyWindow = screenPriv->CopyWindow; pScreen->CopyWindow(pWindow, ptOldOrg, prgnSrc); pScreen->CopyWindow = glWinCopyWindow; }
static void ExaSrcValidate(DrawablePtr pDrawable, int x, int y, int width, int height) { ScreenPtr pScreen = pDrawable->pScreen; ExaScreenPriv(pScreen); PixmapPtr pPix = exaGetDrawablePixmap (pDrawable); BoxRec box; RegionRec reg; RegionPtr dst; int xoff, yoff; exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff); box.x1 = x + xoff; box.y1 = y + yoff; box.x2 = box.x1 + width; box.y2 = box.y1 + height; dst = (pExaScr->srcPix == pPix) ? &pExaScr->srcReg : &pExaScr->maskReg; REGION_INIT(pScreen, ®, &box, 1); REGION_UNION(pScreen, dst, dst, ®); REGION_UNINIT(pScreen, ®); if (pExaScr->SavedSourceValidate) { swap(pExaScr, pScreen, SourceValidate); pScreen->SourceValidate(pDrawable, x, y, width, height); swap(pExaScr, pScreen, SourceValidate); } }
Bool rdpRealizeWindow(WindowPtr pWindow) { ScreenPtr pScreen; rdpWindowRec *priv; Bool rv; LLOGLN(10, ("rdpRealizeWindow:")); priv = GETWINPRIV(pWindow); pScreen = pWindow->drawable.pScreen; pScreen->RealizeWindow = g_rdpScreen.RealizeWindow; rv = pScreen->RealizeWindow(pWindow); pScreen->RealizeWindow = rdpRealizeWindow; if (g_use_rail) { if ((pWindow != g_invalidate_window) && (pWindow->parent != 0)) { if (XR_IS_ROOT(pWindow->parent)) { LLOGLN(10, ("rdpRealizeWindow:")); LLOGLN(10, (" pWindow %p id 0x%x pWindow->parent %p id 0x%x x %d " "y %d width %d height %d", pWindow, (int)(pWindow->drawable.id), pWindow->parent, (int)(pWindow->parent->drawable.id), pWindow->drawable.x, pWindow->drawable.y, pWindow->drawable.width, pWindow->drawable.height)); priv->status = 1; rdpup_create_window(pWindow, priv); } } } return rv; }
Bool rdpUnrealizeWindow(WindowPtr pWindow) { ScreenPtr pScreen; rdpWindowRec *priv; Bool rv; LLOGLN(10, ("rdpUnrealizeWindow:")); priv = GETWINPRIV(pWindow); pScreen = pWindow->drawable.pScreen; pScreen->UnrealizeWindow = g_rdpScreen.UnrealizeWindow; rv = pScreen->UnrealizeWindow(pWindow); pScreen->UnrealizeWindow = rdpUnrealizeWindow; if (g_use_rail) { if (priv->status == 1) { LLOGLN(10, ("rdpUnrealizeWindow:")); priv->status = 0; rdpup_delete_window(pWindow, priv); } } return rv; }
Bool rdpPositionWindow(WindowPtr pWindow, int x, int y) { ScreenPtr pScreen; rdpWindowRec *priv; Bool rv; LLOGLN(10, ("rdpPositionWindow:")); priv = GETWINPRIV(pWindow); pScreen = pWindow->drawable.pScreen; pScreen->PositionWindow = g_rdpScreen.PositionWindow; rv = pScreen->PositionWindow(pWindow, x, y); pScreen->PositionWindow = rdpPositionWindow; if (g_use_rail) { if (priv->status == 1) { LLOGLN(10, ("rdpPositionWindow:")); LLOGLN(10, (" x %d y %d", x, y)); } } return rv; }
Bool rdpDestroyPixmap(PixmapPtr pPixmap) { Bool rv; ScreenPtr pScreen; rdpPixmapRec *priv; LLOGLN(10, ("rdpDestroyPixmap:")); priv = GETPIXPRIV(pPixmap); LLOGLN(10, ("status %d refcnt %d", priv->status, pPixmap->refcnt)); if (pPixmap->refcnt < 2) { if (XRDP_IS_OS(priv)) { rdpup_remove_os_bitmap(priv->rdpindex); rdpup_delete_os_surface(priv->rdpindex); draw_item_remove_all(priv); } } pScreen = pPixmap->drawable.pScreen; pScreen->DestroyPixmap = g_rdpScreen.DestroyPixmap; rv = pScreen->DestroyPixmap(pPixmap); pScreen->DestroyPixmap = rdpDestroyPixmap; return rv; }
vfbCloseScreen(ScreenPtr pScreen) #endif { #if XORG < 113 vfbScreenInfoPtr pvfb = &vfbScreens[index]; #else vfbScreenInfoPtr pvfb = &vfbScreens[pScreen->myNum]; #endif int i; pScreen->CloseScreen = pvfb->closeScreen; /* * XXX probably lots of stuff to clean. For now, * clear installed colormaps so that server reset works correctly. */ #if XORG < 113 for (i = 0; i < MAXSCREENS; i++) InstalledMaps[i] = NULL; return pScreen->CloseScreen(index, pScreen); #else for (i = 0; i < screenInfo.numScreens; i++) SetInstalledColormap(screenInfo.screens[i], NULL); /* * fb overwrites miCloseScreen, so do this here */ if (pScreen->devPrivate) (*pScreen->DestroyPixmap) ((PixmapPtr) pScreen->devPrivate); pScreen->devPrivate = NULL; return pScreen->CloseScreen(pScreen); #endif }
static Bool radeon_glamor_set_shared_pixmap_backing(PixmapPtr pixmap, void *handle) { ScreenPtr screen = pixmap->drawable.pScreen; ScrnInfoPtr scrn = xf86ScreenToScrn(screen); struct radeon_surface surface; struct radeon_pixmap *priv; if (!radeon_set_shared_pixmap_backing(pixmap, handle, &surface)) return FALSE; priv = radeon_get_pixmap_private(pixmap); priv->surface = surface; if (!radeon_glamor_create_textured_pixmap(pixmap, priv)) { xf86DrvMsg(scrn->scrnIndex, X_ERROR, "Failed to get PRIME drawable for glamor pixmap.\n"); return FALSE; } screen->ModifyPixmapHeader(pixmap, pixmap->drawable.width, pixmap->drawable.height, 0, 0, 0, NULL); return TRUE; }
PixmapPtr rdpCreatePixmap(ScreenPtr pScreen, int width, int height, int depth, unsigned usage_hint) { PixmapPtr rv; rdpPixmapRec* priv; int org_width; org_width = width; /* width must be a multiple of 4 in rdp */ width = (width + 3) & ~3; LLOGLN(10, ("rdpCreatePixmap: width %d org_width %d", width, org_width)); pScreen->CreatePixmap = g_rdpScreen.CreatePixmap; rv = pScreen->CreatePixmap(pScreen, width, height, depth, usage_hint); priv = GETPIXPRIV(rv); priv->rdpindex = -1; if ((rv->drawable.depth == g_rdpScreen.depth) && (org_width > 1) && (height > 1)) { priv->allocBytes = width * height * g_Bpp; priv->rdpindex = rdpup_add_os_bitmap(rv, priv); if (priv->rdpindex >= 0) { priv->status = 1; rdpup_create_os_surface(priv->rdpindex, width, height); } } pScreen->ModifyPixmapHeader(rv, org_width, 0, 0, 0, 0, 0); pScreen->CreatePixmap = rdpCreatePixmap; return rv; }
/** * Destroy Buffer */ static void MSMDRI2DestroyBuffer(DrawablePtr pDraw, DRI2BufferPtr buffer) { MSMDRI2BufferPtr buf = MSMBUF(buffer); ScreenPtr pScreen = buf->pPixmap->drawable.pScreen; ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); if (--buf->refcnt) return; DEBUG_MSG("pDraw=%p, buffer=%p, attachment=%d", pDraw, buffer, buffer->attachment); /* if drawable has already gone away, 3rd buf is cleaned * up in MSMDRI2DrawableGone() */ if ((buffer->attachment == DRI2BufferBackLeft) && pDraw) { MSMDRI2DrawablePtr pPriv = MSMDRI2GetDrawable(pDraw); if (pPriv->pThirdBuffer) { MSMDRI2DestroyBuffer(pDraw, pPriv->pThirdBuffer); pPriv->pThirdBuffer = NULL; } } pScreen->DestroyPixmap(buf->pPixmap); free(buf); }
/* * RootlessValidateTree * ValidateTree is modified in two ways: * - top-level windows don't clip each other * - windows aren't clipped against root. * These only matter when validating from the root. */ static int RootlessValidateTree(WindowPtr pParent, WindowPtr pChild, VTKind kind) { int result; RegionRec saveRoot; ScreenPtr pScreen = pParent->drawable.pScreen; SCREEN_UNWRAP(pScreen, ValidateTree); RL_DEBUG_MSG("VALIDATETREE start "); // Use our custom version to validate from root if (IsRoot(pParent)) { RL_DEBUG_MSG("custom "); result = RootlessMiValidateTree(pParent, pChild, kind); } else { HUGE_ROOT(pParent); result = pScreen->ValidateTree(pParent, pChild, kind); NORMAL_ROOT(pParent); } SCREEN_WRAP(pScreen, ValidateTree); RL_DEBUG_MSG("VALIDATETREE end\n"); return result; }
static void crtc_shadow_destroy(xf86CrtcPtr crtc, PixmapPtr rotate_pixmap, void *data) { ScreenPtr pScreen = rotate_pixmap->drawable.pScreen; pScreen->DestroyPixmap(rotate_pixmap); }
void ExaCheckCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) { DrawablePtr pDrawable = &pWin->drawable; ScreenPtr pScreen = pDrawable->pScreen; EXA_PRE_FALLBACK(pScreen); EXA_FALLBACK(("from %p\n", pWin)); /* Only need the source bits, the destination region will be overwritten */ if (pExaScr->prepare_access_reg) { PixmapPtr pPixmap = pScreen->GetWindowPixmap(pWin); int xoff, yoff; exaGetDrawableDeltas(&pWin->drawable, pPixmap, &xoff, &yoff); RegionTranslate(prgnSrc, xoff, yoff); pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, prgnSrc); RegionTranslate(prgnSrc, -xoff, -yoff); } else exaPrepareAccess(pDrawable, EXA_PREPARE_SRC); swap(pExaScr, pScreen, CopyWindow); pScreen->CopyWindow(pWin, ptOldOrg, prgnSrc); swap(pExaScr, pScreen, CopyWindow); exaFinishAccess(pDrawable, EXA_PREPARE_SRC); EXA_POST_FALLBACK(pScreen); }
Bool exaDestroyPixmap_classic(PixmapPtr pPixmap) { ScreenPtr pScreen = pPixmap->drawable.pScreen; ExaScreenPriv(pScreen); Bool ret; if (pPixmap->refcnt == 1) { ExaPixmapPriv(pPixmap); exaDestroyPixmap(pPixmap); if (pExaPixmap->area) { DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n", (void *) pPixmap->drawable.id, ExaGetPixmapPriv(pPixmap)->area->offset, pPixmap->drawable.width, pPixmap->drawable.height)); /* Free the offscreen area */ exaOffscreenFree(pPixmap->drawable.pScreen, pExaPixmap->area); pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr; pPixmap->devKind = pExaPixmap->sys_pitch; } RegionUninit(&pExaPixmap->validSys); RegionUninit(&pExaPixmap->validFB); } swap(pExaScr, pScreen, DestroyPixmap); ret = pScreen->DestroyPixmap(pPixmap); swap(pExaScr, pScreen, DestroyPixmap); return ret; }
/* Fake backing store via automatic redirection */ static Bool compChangeWindowAttributes(WindowPtr pWin, unsigned long mask) { ScreenPtr pScreen = pWin->drawable.pScreen; CompScreenPtr cs = GetCompScreen (pScreen); Bool ret; pScreen->ChangeWindowAttributes = cs->ChangeWindowAttributes; ret = pScreen->ChangeWindowAttributes(pWin, mask); if (ret && (mask & CWBackingStore) && pScreen->backingStoreSupport != NotUseful) { if (pWin->backingStore != NotUseful) { compRedirectWindow(serverClient, pWin, CompositeRedirectAutomatic); pWin->backStorage = (pointer) (intptr_t) 1; } else { compUnredirectWindow(serverClient, pWin, CompositeRedirectAutomatic); pWin->backStorage = NULL; } } pScreen->ChangeWindowAttributes = compChangeWindowAttributes; return ret; }
static Bool XAPixmapIsOffscreen(PixmapPtr pPixmap) { ScreenPtr pScreen = pPixmap->drawable.pScreen; struct xa_surface *surf = msm_get_pixmap_surf(pPixmap); if ((pScreen->GetScreenPixmap(pScreen) == pPixmap)) { return TRUE; } if (!surf) { /* because we are pretending to handle unaccel (1bpp, etc) * pixmaps too.. * this is pretty lame, revisit using EXA_MIXED_PIXMAPS */ struct msm_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); if (priv && priv->ptr) { return TRUE; } } if (surf) return TRUE; return FALSE; }
static inline Bool canexchange(DrawablePtr pDraw, struct armsoc_bo *src_bo, struct armsoc_bo *dst_bo) { Bool ret = FALSE; ScreenPtr pScreen = pDraw->pScreen; PixmapPtr pRootPixmap, pWindowPixmap; int src_fb_id, dst_fb_id; pRootPixmap = pScreen->GetWindowPixmap(pScreen->root); pWindowPixmap = pDraw->type == DRAWABLE_PIXMAP ? (PixmapPtr)pDraw : pScreen->GetWindowPixmap((WindowPtr)pDraw); src_fb_id = armsoc_bo_get_fb(src_bo); dst_fb_id = armsoc_bo_get_fb(dst_bo); if (pRootPixmap != pWindowPixmap && armsoc_bo_width(src_bo) == armsoc_bo_width(dst_bo) && armsoc_bo_height(src_bo) == armsoc_bo_height(dst_bo) && armsoc_bo_bpp(src_bo) == armsoc_bo_bpp(dst_bo) && armsoc_bo_width(src_bo) == pDraw->width && armsoc_bo_height(src_bo) == pDraw->height && armsoc_bo_bpp(src_bo) == pDraw->bitsPerPixel && src_fb_id == 0 && dst_fb_id == 0) { ret = TRUE; } return ret; }
static PixmapPtr createpix(DrawablePtr pDraw) { ScreenPtr pScreen = pDraw->pScreen; return pScreen->CreatePixmap(pScreen, pDraw->width, pDraw->height, pDraw->depth, CREATE_PIXMAP_USAGE_DRI2); }
static PixmapPtr createpix(DrawablePtr pDraw) { ScreenPtr pScreen = pDraw->pScreen; int flags = canflip(pDraw) ? ARMSOC_CREATE_PIXMAP_SCANOUT : 0; return pScreen->CreatePixmap(pScreen, pDraw->width, pDraw->height, pDraw->depth, flags); }
static void xf86_dga_sync(ScrnInfoPtr scrn) { ScreenPtr pScreen = scrn->pScreen; WindowPtr pRoot = WindowTable [pScreen->myNum]; char buffer[4]; pScreen->GetImage (&pRoot->drawable, 0, 0, 1, 1, ZPixmap, ~0L, buffer); }
static void VGAarbiterWakeupHandler(int i, pointer blockData, unsigned long result, pointer pReadmask) { ScreenPtr pScreen = screenInfo.screens[i]; SCREEN_PROLOG(WakeupHandler); VGAGet(pScreen); pScreen->WakeupHandler(i, blockData, result, pReadmask); VGAPut(); SCREEN_EPILOG(WakeupHandler, VGAarbiterWakeupHandler); }
/** * Set the devices' cursor position to the given x/y position. * * This function is called during the pointer update path in * GetPointerEvents and friends (and the same in the xwin DDX). * * The coordinates provided are always absolute. The parameter mode whether * it was relative or absolute movement that landed us at those coordinates. * * @param pDev The device to move * @param mode Movement mode (Absolute or Relative) * @param[in,out] x The x coordiante in screen coordinates (in regards to total * desktop size) * @param[in,out] y The y coordiante in screen coordinates (in regards to total * desktop size) */ void miPointerSetPosition(DeviceIntPtr pDev, int mode, int *x, int *y) { miPointerScreenPtr pScreenPriv; ScreenPtr pScreen; ScreenPtr newScreen; miPointerPtr pPointer; if (!pDev || !pDev->coreEvents) return; pPointer = MIPOINTER(pDev); pScreen = pPointer->pScreen; if (!pScreen) return; /* called before ready */ if (*x < 0 || *x >= pScreen->width || *y < 0 || *y >= pScreen->height) { pScreenPriv = GetScreenPrivate (pScreen); if (!pPointer->confined) { newScreen = pScreen; (*pScreenPriv->screenFuncs->CursorOffScreen) (&newScreen, x, y); if (newScreen != pScreen) { pScreen = newScreen; (*pScreenPriv->screenFuncs->NewEventScreen) (pDev, pScreen, FALSE); pScreenPriv = GetScreenPrivate (pScreen); /* Smash the confine to the new screen */ pPointer->limits.x2 = pScreen->width; pPointer->limits.y2 = pScreen->height; } } } /* Constrain the sprite to the current limits. */ if (*x < pPointer->limits.x1) *x = pPointer->limits.x1; if (*x >= pPointer->limits.x2) *x = pPointer->limits.x2 - 1; if (*y < pPointer->limits.y1) *y = pPointer->limits.y1; if (*y >= pPointer->limits.y2) *y = pPointer->limits.y2 - 1; if (pScreen->ConstrainCursorHarder) pScreen->ConstrainCursorHarder(pDev, pScreen, mode, x, y); if (pPointer->x == *x && pPointer->y == *y && pPointer->pScreen == pScreen) return; miPointerMoveNoEvent(pDev, pScreen, *x, *y); }
static int y_flip(PixmapPtr pixmap, int y) { ScreenPtr screen = pixmap->drawable.pScreen; PixmapPtr screen_pixmap = screen->GetScreenPixmap(screen); if (pixmap == screen_pixmap) return (pixmap->drawable.height - 1) - y; else return y; }
static void VGAarbiterBlockHandler(int i, pointer blockData, pointer pTimeout, pointer pReadmask) { ScreenPtr pScreen = screenInfo.screens[i]; SCREEN_PROLOG(BlockHandler); VGAGet(pScreen); pScreen->BlockHandler(i, blockData, pTimeout, pReadmask); VGAPut(); SCREEN_EPILOG(BlockHandler, VGAarbiterBlockHandler); }