/** Fill a rectangle on the appropriate screen by combining the color * with the dest picture in the area specified by the list of * rectangles. For a complete description see the protocol document of * the RENDER library. */ void dmxCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor * color, int nRect, xRectangle *rects) { ScreenPtr pScreen = pDst->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pDst); DMX_UNWRAP(CompositeRects, dmxScreen, ps); #if 0 if (ps->CompositeRects) ps->CompositeRects(op, pDst, color, nRect, rects); #endif /* CompositeRects on back-end server */ if (pPictPriv->pict) { XRenderFillRectangles(dmxScreen->beDisplay, op, pPictPriv->pict, (XRenderColor *) color, (XRectangle *) rects, nRect); dmxSync(dmxScreen, FALSE); } DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps); }
int miChangePictureClip(PicturePtr pPicture, int type, void *value, int n) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); RegionPtr clientClip; switch (type) { case CT_PIXMAP: /* convert the pixmap to a region */ clientClip = BitmapToRegion(pScreen, (PixmapPtr) value); if (!clientClip) return BadAlloc; (*pScreen->DestroyPixmap) ((PixmapPtr) value); break; case CT_REGION: clientClip = value; break; case CT_NONE: clientClip = 0; break; default: clientClip = RegionFromRects(n, (xRectangle *) value, type); if (!clientClip) return BadAlloc; free(value); break; } (*ps->DestroyPictureClip) (pPicture); pPicture->clientClip = clientClip; pPicture->stateChanges |= CPClipMask; return Success; }
/** Initialize the RENDER extension, allocate the picture privates and * wrap mi function hooks. If the shadow frame buffer is used, then * call the appropriate fb initialization function. */ Bool dmxPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats) { DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps; if (!miPictureInit(pScreen, formats, nformats)) return FALSE; if (!dixRegisterPrivateKey (&dmxPictPrivateKeyRec, PRIVATE_PICTURE, sizeof(dmxPictPrivRec))) return FALSE; ps = GetPictureScreen(pScreen); DMX_WRAP(CreatePicture, dmxCreatePicture, dmxScreen, ps); DMX_WRAP(DestroyPicture, dmxDestroyPicture, dmxScreen, ps); DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps); DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps); DMX_WRAP(ChangePicture, dmxChangePicture, dmxScreen, ps); DMX_WRAP(ValidatePicture, dmxValidatePicture, dmxScreen, ps); DMX_WRAP(Composite, dmxComposite, dmxScreen, ps); DMX_WRAP(Glyphs, dmxGlyphs, dmxScreen, ps); DMX_WRAP(CompositeRects, dmxCompositeRects, dmxScreen, ps); DMX_WRAP(Trapezoids, dmxTrapezoids, dmxScreen, ps); DMX_WRAP(Triangles, dmxTriangles, dmxScreen, ps); return TRUE; }
/** Destroy the picture's list of clip rectangles. */ void dmxDestroyPictureClip(PicturePtr pPicture) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); DMX_UNWRAP(DestroyPictureClip, dmxScreen, ps); #if 1 if (ps->DestroyPictureClip) ps->DestroyPictureClip(pPicture); #endif /* Destroy picture clip rects on back-end server */ if (pPictPriv->pict) { XRenderSetPictureClipRectangles(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, NULL, 0); dmxSync(dmxScreen, FALSE); } else { /* FIXME: Handle destroying clip region when offscreen */ } DMX_WRAP(DestroyPictureClip, dmxDestroyPictureClip, dmxScreen, ps); }
static void RootlessComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) { ScreenPtr pScreen = pDst->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); WindowPtr dstWin; dstWin = (pDst->pDrawable->type == DRAWABLE_WINDOW) ? (WindowPtr)pDst->pDrawable : NULL; // SCREEN_UNWRAP(ps, Composite); ps->Composite = SCREENREC(pScreen)->Composite; ps->Composite(op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); if (dstWin && IsFramedWindow(dstWin)) { RootlessDamageRect(dstWin, xDst, yDst, width, height); } ps->Composite = RootlessComposite; // SCREEN_WRAP(ps, Composite); }
void rdpGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists, GlyphPtr* glyphs) { PictureScreenPtr ps; int index; LLOGLN(10, ("rdpGlyphs:")); LLOGLN(10, ("rdpGlyphs: nlists %d len %d", nlists, lists->len)); rdpup_set_hints(1, 1); for (index = 0; index < lists->len; index++) { LLOGLN(10, (" index %d size %d refcnt %d width %d height %d", index, (int)(glyphs[index]->size), (int)(glyphs[index]->refcnt), glyphs[index]->info.width, glyphs[index]->info.height)); } ps = GetPictureScreen(g_pScreen); ps->Glyphs = g_rdpScreen.Glyphs; ps->Glyphs(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlists, lists, glyphs); ps->Glyphs = rdpGlyphs; rdpup_set_hints(0, 1); LLOGLN(10, ("rdpGlyphs: out")); }
Bool LayerFinishInit (ScreenPtr pScreen) { #ifdef RENDER PictureScreenPtr ps = GetPictureScreen (pScreen); #endif pScreen->CloseScreen = layerCloseScreen; pScreen->CreateWindow = layerCreateWindow; pScreen->DestroyWindow = layerDestroyWindow; pScreen->ChangeWindowAttributes = layerChangeWindowAttributes; pScreen->PaintWindowBackground = layerPaintWindowBackground; pScreen->PaintWindowBorder = layerPaintWindowBorder; pScreen->CopyWindow = layerCopyWindow; pScreen->CreatePixmap = layerCreatePixmap; pScreen->DestroyPixmap = layerDestroyPixmap; pScreen->CreateGC = layerCreateGC; #ifdef RENDER if (ps) { ps->Composite = layerComposite; ps->Glyphs = layerGlyphs; ps->CompositeRects = layerCompositeRects; } #endif return TRUE; }
_X_EXPORT Bool PictureSetFilterAlias (ScreenPtr pScreen, char *filter, char *alias) { PictureScreenPtr ps = GetPictureScreen(pScreen); int filter_id = PictureGetFilterId (filter, -1, FALSE); int alias_id = PictureGetFilterId (alias, -1, TRUE); int i; if (filter_id < 0 || alias_id < 0) return FALSE; for (i = 0; i < ps->nfilterAliases; i++) if (ps->filterAliases[i].alias_id == alias_id) break; if (i == ps->nfilterAliases) { PictFilterAliasPtr aliases; if (ps->filterAliases) aliases = xrealloc (ps->filterAliases, (ps->nfilterAliases + 1) * sizeof (PictFilterAliasRec)); else aliases = xalloc (sizeof (PictFilterAliasRec)); if (!aliases) return FALSE; ps->filterAliases = aliases; ps->filterAliases[i].alias = PictureGetFilterName (alias_id); ps->filterAliases[i].alias_id = alias_id; ps->nfilterAliases++; } ps->filterAliases[i].filter_id = filter_id; return TRUE; }
_X_EXPORT int PictureAddFilter (ScreenPtr pScreen, char *filter, PictFilterValidateParamsProcPtr ValidateParams) { PictureScreenPtr ps = GetPictureScreen(pScreen); int id = PictureGetFilterId (filter, -1, TRUE); int i; PictFilterPtr filters; if (id < 0) return -1; /* * It's an error to attempt to reregister a filter */ for (i = 0; i < ps->nfilters; i++) if (ps->filters[i].id == id) return -1; if (ps->filters) filters = xrealloc (ps->filters, (ps->nfilters + 1) * sizeof (PictFilterRec)); else filters = xalloc (sizeof (PictFilterRec)); if (!filters) return -1; ps->filters = filters; i = ps->nfilters++; ps->filters[i].name = PictureGetFilterName (id); ps->filters[i].id = id; ps->filters[i].ValidateParams = ValidateParams; return id; }
/* * xprSetupScreen * Setup the screen for rootless access. */ static Bool xprSetupScreen(int index, ScreenPtr pScreen) { // Add alpha protecting replacements for fb screen functions pScreen->PaintWindowBackground = SafeAlphaPaintWindow; pScreen->PaintWindowBorder = SafeAlphaPaintWindow; #ifdef RENDER { PictureScreenPtr ps = GetPictureScreen(pScreen); ps->Composite = SafeAlphaComposite; } #endif /* RENDER */ // Initialize accelerated rootless drawing // Note that this must be done before DamageSetup(). RootlessAccelInit(pScreen); #ifdef DAMAGE // The Damage extension needs to wrap underneath the // generic rootless layer, so do it now. if (!DamageSetup(pScreen)) return FALSE; #endif // Initialize generic rootless code if (!xprInit(pScreen)) return FALSE; return DRIFinishScreenInit(pScreen); }
void rdpComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) { ScreenPtr pScreen; rdpPtr dev; PictureScreenPtr ps; BoxRec box; RegionRec reg; LLOGLN(10, ("rdpComposite:")); pScreen = pDst->pDrawable->pScreen; dev = rdpGetDevFromScreen(pScreen); dev->counts.rdpCompositeCallCount++; box.x1 = xDst + pDst->pDrawable->x; box.y1 = yDst + pDst->pDrawable->y; box.x2 = box.x1 + width; box.y2 = box.y1 + height; rdpRegionInit(®, &box, 0); if (pDst->pCompositeClip != NULL) { rdpRegionIntersect(®, pDst->pCompositeClip, ®); } ps = GetPictureScreen(pScreen); /* do original call */ rdpCompositeOrg(ps, dev, op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); rdpClientConAddAllReg(dev, ®, pDst->pDrawable); rdpRegionUninit(®); }
/** Change the picture's list of clip rectangles. */ int dmxChangePictureClip(PicturePtr pPicture, int clipType, pointer value, int n) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; PictureScreenPtr ps = GetPictureScreen(pScreen); dmxPictPrivPtr pPictPriv = DMX_GET_PICT_PRIV(pPicture); DMX_UNWRAP(ChangePictureClip, dmxScreen, ps); #if 1 if (ps->ChangePictureClip) ps->ChangePictureClip(pPicture, clipType, value, n); #endif /* Change picture clip rects on back-end server */ if (pPictPriv->pict) { /* The clip has already been changed into a region by the mi * routine called above. */ if (pPicture->clientClip) { RegionPtr pClip = pPicture->clientClip; BoxPtr pBox = REGION_RECTS(pClip); int nBox = REGION_NUM_RECTS(pClip); XRectangle *pRects; XRectangle *pRect; int nRects; nRects = nBox; pRects = pRect = xalloc(nRects * sizeof(*pRect)); while (nBox--) { pRect->x = pBox->x1; pRect->y = pBox->y1; pRect->width = pBox->x2 - pBox->x1; pRect->height = pBox->y2 - pBox->y1; pBox++; pRect++; } XRenderSetPictureClipRectangles(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, pRects, nRects); xfree(pRects); } else { XRenderSetPictureClipRectangles(dmxScreen->beDisplay, pPictPriv->pict, 0, 0, NULL, 0); } dmxSync(dmxScreen, FALSE); } else { /* FIXME: Handle saving clip region when offscreen */ } DMX_WRAP(ChangePictureClip, dmxChangePictureClip, dmxScreen, ps); return Success; }
void KdPictureInitAsync (ScreenPtr pScreen) { PictureScreenPtr ps; ps = GetPictureScreen(pScreen); ps->Composite = KdCheckComposite; }
void GlyphUninit (ScreenPtr pScreen) { PictureScreenPtr ps = GetPictureScreen (pScreen); GlyphPtr glyph; int fdepth, i; globalTotalGlyphPrivateSize -= ps->totalGlyphPrivateSize; for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++) { if (!globalGlyphs[fdepth].hashSet) continue; for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++) { glyph = globalGlyphs[fdepth].table[i].glyph; if (glyph && glyph != DeletedGlyph) { (*ps->UnrealizeGlyph) (pScreen, glyph); if (globalTotalGlyphPrivateSize) { if (!ReallocGlobalGlyphPrivate (glyph)) return; } else { if (glyph->devPrivates) xfree (glyph->devPrivates); glyph->devPrivates = NULL; } } } } if (globalTotalGlyphPrivateSize) SetGlyphScreenPrivateOffsets (); for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++) { if (!globalGlyphs[fdepth].hashSet) continue; for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++) { glyph = globalGlyphs[fdepth].table[i].glyph; if (glyph && glyph != DeletedGlyph) { if (globalTotalGlyphPrivateSize) SetGlyphPrivatePointers (glyph); } } } if (ps->glyphPrivateSizes) xfree (ps->glyphPrivateSizes); }
void PictureResetFilters (ScreenPtr pScreen) { PictureScreenPtr ps = GetPictureScreen(pScreen); xfree (ps->filters); xfree (ps->filterAliases); PictureFreeFilterIds (); }
int SetPictureFilter (PicturePtr pPicture, char *name, int len, xFixed *params, int nparams) { PictFilterPtr pFilter; xFixed *new_params; int i, s, result; pFilter = PictureFindFilter (screenInfo.screens[0], name, len); if (pPicture->pDrawable == NULL) { /* For source pictures, the picture isn't tied to a screen. So, ensure * that all screens can handle a filter we set for the picture. */ for (s = 0; s < screenInfo.numScreens; s++) { if (PictureFindFilter (screenInfo.screens[s], name, len)->id != pFilter->id) { return BadMatch; } } } if (!pFilter) return BadName; if (pFilter->ValidateParams) { if (!(*pFilter->ValidateParams) (pPicture, pFilter->id, params, nparams)) return BadMatch; } else if (nparams) return BadMatch; if (nparams != pPicture->filter_nparams) { new_params = xalloc (nparams * sizeof (xFixed)); if (!new_params) return BadAlloc; xfree (pPicture->filter_params); pPicture->filter_params = new_params; pPicture->filter_nparams = nparams; } for (i = 0; i < nparams; i++) pPicture->filter_params[i] = params[i]; pPicture->filter = pFilter->id; if (pPicture->pDrawable) { ScreenPtr pScreen = pPicture->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); result = (*ps->ChangePictureFilter) (pPicture, pPicture->filter, params, nparams); return result; } return Success; }
static void RootlessWrap(ScreenPtr pScreen) { RootlessScreenRec *s = (RootlessScreenRec*) pScreen->devPrivates[rootlessScreenPrivateIndex].ptr; #define WRAP(a) \ if (pScreen->a) { \ s->a = pScreen->a; \ } else { \ RL_DEBUG_MSG("null screen fn " #a "\n"); \ s->a = NULL; \ } \ pScreen->a = Rootless##a WRAP(CloseScreen); WRAP(CreateGC); WRAP(PaintWindowBackground); WRAP(PaintWindowBorder); WRAP(CopyWindow); WRAP(GetImage); WRAP(CreateWindow); WRAP(DestroyWindow); WRAP(RealizeWindow); WRAP(UnrealizeWindow); WRAP(MoveWindow); WRAP(PositionWindow); WRAP(ResizeWindow); WRAP(RestackWindow); WRAP(ChangeBorderWidth); WRAP(MarkOverlappedWindows); WRAP(ValidateTree); WRAP(ChangeWindowAttributes); #ifdef SHAPE WRAP(SetShape); #endif #ifdef RENDER { // Composite and Glyphs don't use normal screen wrapping PictureScreenPtr ps = GetPictureScreen(pScreen); s->Composite = ps->Composite; ps->Composite = RootlessComposite; s->Glyphs = ps->Glyphs; ps->Glyphs = RootlessGlyphs; } #endif // WRAP(ClearToBackground); fixme put this back? useful for shaped wins? // WRAP(RestoreAreas); fixme put this back? #undef WRAP }
Bool GlyphFinishInit (ScreenPtr pScreen) { PictureScreenPtr ps = GetPictureScreen (pScreen); if (ps->totalGlyphPrivateSize) { GlyphPtr glyph; int fdepth, i; globalTotalGlyphPrivateSize += ps->totalGlyphPrivateSize; for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++) { if (!globalGlyphs[fdepth].hashSet) continue; for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++) { glyph = globalGlyphs[fdepth].table[i].glyph; if (glyph && glyph != DeletedGlyph) { if (!ReallocGlobalGlyphPrivate (glyph)) return FALSE; } } } SetGlyphScreenPrivateOffsets (); for (fdepth = 0; fdepth < GlyphFormatNum; fdepth++) { if (!globalGlyphs[fdepth].hashSet) continue; for (i = 0; i < globalGlyphs[fdepth].hashSet->size; i++) { glyph = globalGlyphs[fdepth].table[i].glyph; if (glyph && glyph != DeletedGlyph) { SetGlyphPrivatePointers (glyph); if (!(*ps->RealizeGlyph) (pScreen, glyph)) return FALSE; } } } } else ps->glyphPrivateOffset = 0; return TRUE; }
void miTrapezoids (CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntrap, xTrapezoid *traps) { ScreenPtr pScreen = pDst->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); /* * Check for solid alpha add */ if (op == PictOpAdd && miIsSolidAlpha (pSrc)) { for (; ntrap; ntrap--, traps++) (*ps->RasterizeTrapezoid) (pDst, traps, 0, 0); } else if (maskFormat) { PicturePtr pPicture; BoxRec bounds; INT16 xDst, yDst; INT16 xRel, yRel; xDst = traps[0].left.p1.x >> 16; yDst = traps[0].left.p1.y >> 16; miTrapezoidBounds (ntrap, traps, &bounds); if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2) return; pPicture = miCreateAlphaPicture (pScreen, pDst, maskFormat, bounds.x2 - bounds.x1, bounds.y2 - bounds.y1); if (!pPicture) return; for (; ntrap; ntrap--, traps++) (*ps->RasterizeTrapezoid) (pPicture, traps, -bounds.x1, -bounds.y1); xRel = bounds.x1 + xSrc - xDst; yRel = bounds.y1 + ySrc - yDst; CompositePicture (op, pSrc, pPicture, pDst, xRel, yRel, 0, 0, bounds.x1, bounds.y1, bounds.x2 - bounds.x1, bounds.y2 - bounds.y1); FreePicture (pPicture, 0); } else { if (pDst->polyEdge == PolyEdgeSharp)
Bool GlyphInit(ScreenPtr pScreen) { PictureScreenPtr ps = GetPictureScreen(pScreen); ps->totalGlyphPrivateSize = 0; ps->glyphPrivateSizes = 0; ps->glyphPrivateLen = 0; ps->glyphPrivateOffset = -1; return TRUE; }
static void RootlessWrap(ScreenPtr pScreen) { RootlessScreenRec *s = SCREENREC(pScreen); #define WRAP(a) \ if (pScreen->a) { \ s->a = pScreen->a; \ } else { \ RL_DEBUG_MSG("null screen fn " #a "\n"); \ s->a = NULL; \ } \ pScreen->a = Rootless##a WRAP(CreateScreenResources); WRAP(CloseScreen); WRAP(CreateGC); WRAP(CopyWindow); WRAP(GetImage); WRAP(SourceValidate); WRAP(CreateWindow); WRAP(DestroyWindow); WRAP(RealizeWindow); WRAP(UnrealizeWindow); WRAP(MoveWindow); WRAP(PositionWindow); WRAP(ResizeWindow); WRAP(RestackWindow); WRAP(ReparentWindow); WRAP(ChangeBorderWidth); WRAP(MarkOverlappedWindows); WRAP(ValidateTree); WRAP(ChangeWindowAttributes); WRAP(InstallColormap); WRAP(UninstallColormap); WRAP(StoreColors); WRAP(SetShape); { // Composite and Glyphs don't use normal screen wrapping PictureScreenPtr ps = GetPictureScreen(pScreen); s->Composite = ps->Composite; ps->Composite = RootlessComposite; s->Glyphs = ps->Glyphs; ps->Glyphs = RootlessGlyphs; } // WRAP(ClearToBackground); fixme put this back? useful for shaped wins? #undef WRAP }
static void ShadowComposite( CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height ){ ScreenPtr pScreen = pDst->pDrawable->pScreen; ShadowScreenPtr pPriv = GET_SCREEN_PRIVATE(pScreen); PictureScreenPtr ps = GetPictureScreen(pScreen); BoxRec box; BoxPtr extents; Bool boxNotEmpty = FALSE; if (pPriv->vtSema && pDst->pDrawable->type == DRAWABLE_WINDOW) { box.x1 = pDst->pDrawable->x + xDst; box.y1 = pDst->pDrawable->y + yDst; box.x2 = box.x1 + width; box.y2 = box.y1 + height; extents = &pDst->pCompositeClip->extents; if(box.x1 < extents->x1) box.x1 = extents->x1; if(box.x2 > extents->x2) box.x2 = extents->x2; if(box.y1 < extents->y1) box.y1 = extents->y1; if(box.y2 > extents->y2) box.y2 = extents->y2; if (BOX_NOT_EMPTY(box)) { if (pPriv->preRefresh) (*pPriv->preRefresh)(pPriv->pScrn, 1, &box); boxNotEmpty = TRUE; } } ps->Composite = pPriv->Composite; (*ps->Composite)(op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); ps->Composite = ShadowComposite; if (pPriv->postRefresh && boxNotEmpty) { (*pPriv->postRefresh)(pPriv->pScrn, 1, &box); } }
/* Screen initialization/teardown */ void miInitializeCompositeWrapper(ScreenPtr pScreen) { cwScreenPtr pScreenPriv; if (cwDisabled[pScreen->myNum]) return; if (cwGeneration != serverGeneration) { cwScreenIndex = AllocateScreenPrivateIndex(); if (cwScreenIndex < 0) return; cwGCIndex = AllocateGCPrivateIndex(); cwWindowIndex = AllocateWindowPrivateIndex(); #ifdef RENDER cwPictureIndex = AllocatePicturePrivateIndex(); #endif cwGeneration = serverGeneration; } if (!AllocateGCPrivate(pScreen, cwGCIndex, sizeof(cwGCRec))) return; if (!AllocateWindowPrivate(pScreen, cwWindowIndex, 0)) return; #ifdef RENDER if (!AllocatePicturePrivate(pScreen, cwPictureIndex, 0)) return; #endif pScreenPriv = (cwScreenPtr)xalloc(sizeof(cwScreenRec)); if (!pScreenPriv) return; pScreen->devPrivates[cwScreenIndex].ptr = (pointer)pScreenPriv; SCREEN_EPILOGUE(pScreen, CloseScreen, cwCloseScreen); SCREEN_EPILOGUE(pScreen, GetImage, cwGetImage); SCREEN_EPILOGUE(pScreen, GetSpans, cwGetSpans); SCREEN_EPILOGUE(pScreen, CreateGC, cwCreateGC); SCREEN_EPILOGUE(pScreen, PaintWindowBackground, cwPaintWindowBackground); SCREEN_EPILOGUE(pScreen, PaintWindowBorder, cwPaintWindowBorder); SCREEN_EPILOGUE(pScreen, CopyWindow, cwCopyWindow); SCREEN_EPILOGUE(pScreen, SetWindowPixmap, cwSetWindowPixmap); SCREEN_EPILOGUE(pScreen, GetWindowPixmap, cwGetWindowPixmap); #ifdef RENDER if (GetPictureScreen (pScreen)) cwInitializeRender(pScreen); #endif }
void miTriangles (CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int ntri, xTriangle *tris) { ScreenPtr pScreen = pDst->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); /* * Check for solid alpha add */ if (op == PictOpAdd && miIsSolidAlpha (pSrc)) { (*ps->AddTriangles) (pDst, 0, 0, ntri, tris); } else if (maskFormat) { BoxRec bounds; PicturePtr pPicture; INT16 xDst, yDst; INT16 xRel, yRel; xDst = tris[0].p1.x >> 16; yDst = tris[0].p1.y >> 16; miTriangleBounds (ntri, tris, &bounds); if (bounds.x2 <= bounds.x1 || bounds.y2 <= bounds.y1) return; pPicture = miCreateAlphaPicture (pScreen, pDst, maskFormat, bounds.x2 - bounds.x1, bounds.y2 - bounds.y1); if (!pPicture) return; (*ps->AddTriangles) (pPicture, -bounds.x1, -bounds.y1, ntri, tris); xRel = bounds.x1 + xSrc - xDst; yRel = bounds.y1 + ySrc - yDst; CompositePicture (op, pSrc, pPicture, pDst, xRel, yRel, 0, 0, bounds.x1, bounds.y1, bounds.x2 - bounds.x1, bounds.y2 - bounds.y1); FreePicture (pPicture, 0); } else { if (pDst->polyEdge == PolyEdgeSharp)
static void VGAarbiterCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor * color, int nRect, xRectangle *rects) { ScreenPtr pScreen = pDst->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); PICTURE_PROLOGUE(CompositeRects); VGAGet(pScreen); (*ps->CompositeRects) (op, pDst, color, nRect, rects); VGAPut(); PICTURE_EPILOGUE(CompositeRects, VGAarbiterCompositeRects); }
void CompositeGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist, GlyphListPtr lists, GlyphPtr * glyphs) { PictureScreenPtr ps = GetPictureScreen(pDst->pDrawable->pScreen); ValidatePicture(pSrc); ValidatePicture(pDst); (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, lists, glyphs); }
static void VGAarbiterGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs) { ScreenPtr pScreen = pDst->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); PICTURE_PROLOGUE(Glyphs); VGAGet(pScreen); (*ps->Glyphs) (op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs); VGAPut(); PICTURE_EPILOGUE(Glyphs, VGAarbiterGlyphs); }
Bool tridentDrawInit (ScreenPtr pScreen) { SetupTrident(pScreen); tridentScreenInfo(pScreenPriv); PictureScreenPtr ps = GetPictureScreen(pScreen); if (!kaaDrawInit (pScreen, &tridentKaa)) return FALSE; if (ps && tridents->off_screen) ps->Composite = tridentComposite; return TRUE; }
static void VGAarbiterComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height) { ScreenPtr pScreen = pDst->pDrawable->pScreen; PictureScreenPtr ps = GetPictureScreen(pScreen); PICTURE_PROLOGUE(Composite); VGAGet(pScreen); (*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst, yDst, width, height); VGAPut(); PICTURE_EPILOGUE(Composite, VGAarbiterComposite); }
void rdpGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlists, GlyphListPtr lists, GlyphPtr *glyphs) { ScreenPtr pScreen; rdpPtr dev; PictureScreenPtr ps; LLOGLN(10, ("rdpGlyphs:")); pScreen = pDst->pDrawable->pScreen; dev = rdpGetDevFromScreen(pScreen); ps = GetPictureScreen(pScreen); rdpGlyphsOrg(ps, dev, op, pSrc, pDst, maskFormat, xSrc, ySrc, nlists, lists, glyphs); }