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");
}
static void
RootlessPaintWindowBorder(WindowPtr pWin, RegionPtr pRegion, int what)
{
SCREEN_UNWRAP(pWin->drawable.pScreen, PaintWindowBorder);
RL_DEBUG_MSG("paintwindowborder start (win 0x%x) ", pWin);
pWin->drawable.pScreen->PaintWindowBorder(pWin, pRegion, what);
if (IsFramedWindow(pWin)) {
RootlessDamageRegion(pWin, pRegion);
}
SCREEN_WRAP(pWin->drawable.pScreen, PaintWindowBorder);
RL_DEBUG_MSG("paintwindowborder end\n");
}
void
miPaintWindow(WindowPtr pWin, RegionPtr prgn, int what)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
ChangeGCVal gcval[6];
BITS32 gcmask;
GCPtr pGC;
int i;
BoxPtr pbox;
xRectangle *prect;
int numRects;
/*
* Distance from screen to destination drawable, use this
* to adjust rendering coordinates which come in in screen space
*/
int draw_x_off, draw_y_off;
/*
* Tile offset for drawing; these need to align the tile
* to the appropriate window origin
*/
int tile_x_off, tile_y_off;
PixUnion fill;
Bool solid = TRUE;
DrawablePtr drawable = &pWin->drawable;
#ifdef ROOTLESS
if (!drawable || drawable->type == UNDRAWABLE_WINDOW)
return;
if (IsFramedWindow(pWin)) {
RootlessStartDrawing(pWin);
RootlessDamageRegion(pWin, prgn);
if (pWin->backgroundState == ParentRelative) {
if ((what == PW_BACKGROUND) ||
(what == PW_BORDER && !pWin->borderIsPixel))
RootlessSetPixmapOfAncestors(pWin);
}
}
#endif
if (what == PW_BACKGROUND) {
while (pWin->backgroundState == ParentRelative)
pWin = pWin->parent;
draw_x_off = drawable->x;
draw_y_off = drawable->y;
tile_x_off = pWin->drawable.x - draw_x_off;
tile_y_off = pWin->drawable.y - draw_y_off;
fill = pWin->background;
#ifdef COMPOSITE
if (pWin->inhibitBGPaint)
return;
#endif
switch (pWin->backgroundState) {
case None:
return;
case BackgroundPixmap:
solid = FALSE;
break;
}
}
else {
PixmapPtr pixmap;
tile_x_off = drawable->x;
tile_y_off = drawable->y;
/* servers without pixmaps draw their own borders */
if (!pScreen->GetWindowPixmap)
return;
pixmap = (*pScreen->GetWindowPixmap) ((WindowPtr) drawable);
drawable = &pixmap->drawable;
#ifdef COMPOSITE
draw_x_off = pixmap->screen_x;
draw_y_off = pixmap->screen_y;
tile_x_off -= draw_x_off;
tile_y_off -= draw_y_off;
#else
draw_x_off = 0;
draw_y_off = 0;
#endif
fill = pWin->border;
solid = pWin->borderIsPixel;
}
gcval[0].val = GXcopy;
gcmask = GCFunction;
#ifdef ROOTLESS_SAFEALPHA
/* Bit mask for alpha channel with a particular number of bits per
* pixel. Note that we only care for 32bpp data. Mac OS X uses planar
* alpha for 16bpp.
*/
#define RootlessAlphaMask(bpp) ((bpp) == 32 ? 0xFF000000 : 0)
#endif
if (solid) {
#ifdef ROOTLESS_SAFEALPHA
gcval[1].val =
fill.pixel | RootlessAlphaMask(pWin->drawable.bitsPerPixel);
#else
gcval[1].val = fill.pixel;
#endif
gcval[2].val = FillSolid;
gcmask |= GCForeground | GCFillStyle;
}
else {
int c = 1;
#ifdef ROOTLESS_SAFEALPHA
gcval[c++].val =
((CARD32) -1) & ~RootlessAlphaMask(pWin->drawable.bitsPerPixel);
gcmask |= GCPlaneMask;
#endif
gcval[c++].val = FillTiled;
gcval[c++].ptr = (void *) fill.pixmap;
gcval[c++].val = tile_x_off;
gcval[c++].val = tile_y_off;
gcmask |= GCFillStyle | GCTile | GCTileStipXOrigin | GCTileStipYOrigin;
}
prect = malloc(RegionNumRects(prgn) * sizeof(xRectangle));
if (!prect)
return;
pGC = GetScratchGC(drawable->depth, drawable->pScreen);
if (!pGC) {
free(prect);
return;
}
ChangeGC(NullClient, pGC, gcmask, gcval);
ValidateGC(drawable, pGC);
numRects = RegionNumRects(prgn);
pbox = RegionRects(prgn);
for (i = numRects; --i >= 0; pbox++, prect++) {
prect->x = pbox->x1 - draw_x_off;
prect->y = pbox->y1 - draw_y_off;
prect->width = pbox->x2 - pbox->x1;
prect->height = pbox->y2 - pbox->y1;
}
prect -= numRects;
(*pGC->ops->PolyFillRect) (drawable, pGC, numRects, prect);
free(prect);
FreeScratchGC(pGC);
}
