static void
RootlessPutImage(DrawablePtr dst, GCPtr pGC,
int depth, int x, int y, int w, int h,
int leftPad, int format, char *pBits)
{
BoxRec box;
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("put image start ");
RootlessStartDrawing((WindowPtr) dst);
pGC->ops->PutImage(dst, pGC, depth, x, y, w, h, leftPad, format, pBits);
box.x1 = x + dst->x;
box.x2 = box.x1 + w;
box.y1 = y + dst->y;
box.y2 = box.y1 + h;
TRIM_BOX(box, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
GCOP_WRAP(pGC);
RL_DEBUG_MSG("put image end\n");
}
/* changed area is *dest* rect */
static RegionPtr
RootlessCopyPlane(DrawablePtr pSrc, DrawablePtr dst,
GCPtr pGC, int srcx, int srcy,
int w, int h, int dstx, int dsty, unsigned long plane)
{
RegionPtr result;
BoxRec box;
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("copy plane start ");
if (pSrc->type == DRAWABLE_WINDOW && IsFramedWindow((WindowPtr) pSrc)) {
RootlessStartDrawing((WindowPtr) pSrc);
}
RootlessStartDrawing((WindowPtr) dst);
result = pGC->ops->CopyPlane(pSrc, dst, pGC, srcx, srcy, w, h,
dstx, dsty, plane);
box.x1 = dstx + dst->x;
box.x2 = box.x1 + w;
box.y1 = dsty + dst->y;
box.y2 = box.y1 + h;
TRIM_BOX(box, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
GCOP_WRAP(pGC);
RL_DEBUG_MSG("copy plane end\n");
return result;
}
static void
ShadowPutImage(DrawablePtr pDraw,
GCPtr pGC,
int depth,
int x, int y, int w, int h,
int leftPad, int format, char *pImage)
{
BoxRec box;
Bool boxNotEmpty = FALSE;
SHADOW_GC_OP_PROLOGUE(pGC);
if (IS_VISIBLE(pDraw)) {
box.x1 = x + pDraw->x;
box.x2 = box.x1 + w;
box.y1 = y + pDraw->y;
box.y2 = box.y1 + h;
TRIM_BOX(box, pGC);
if (BOX_NOT_EMPTY(box)) {
if (pPriv->preRefresh)
(*pPriv->preRefresh) (pPriv->pScrn, 1, &box);
boxNotEmpty = TRUE;
}
}
(*pGC->ops->PutImage) (pDraw, pGC, depth, x, y, w, h,
leftPad, format, pImage);
if (boxNotEmpty && pPriv->postRefresh)
(*pPriv->postRefresh) (pPriv->pScrn, 1, &box);
SHADOW_GC_OP_EPILOGUE(pGC);
}
static void
ShadowSetSpans(
DrawablePtr pDraw,
GCPtr pGC,
char *pcharsrc,
DDXPointPtr pptInit,
int *pwidthInit,
int nspans,
int fSorted
){
SHADOW_GC_OP_PROLOGUE(pGC);
if(IS_VISIBLE(pDraw) && nspans) {
DDXPointPtr ppt = pptInit;
int *pwidth = pwidthInit;
int i = nspans;
BoxRec box;
Bool boxNotEmpty = FALSE;
box.x1 = ppt->x;
box.x2 = box.x1 + *pwidth;
box.y2 = box.y1 = ppt->y;
while(--i) {
ppt++;
pwidth++;
if(box.x1 > ppt->x) box.x1 = ppt->x;
if(box.x2 < (ppt->x + *pwidth))
box.x2 = ppt->x + *pwidth;
if(box.y1 > ppt->y) box.y1 = ppt->y;
else if(box.y2 < ppt->y) box.y2 = ppt->y;
}
box.y2++;
if(!pGC->miTranslate) {
TRANSLATE_BOX(box, pDraw);
}
TRIM_BOX(box, pGC);
if(BOX_NOT_EMPTY(box)) {
if(pPriv->preRefresh)
(*pPriv->preRefresh)(pPriv->pScrn, 1, &box);
boxNotEmpty = TRUE;
}
(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, pptInit,
pwidthInit, nspans, fSorted);
if(boxNotEmpty && pPriv->postRefresh)
(*pPriv->postRefresh)(pPriv->pScrn, 1, &box);
} else
(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, pptInit,
pwidthInit, nspans, fSorted);
SHADOW_GC_OP_EPILOGUE(pGC);
}
static void
RootlessFillSpans(DrawablePtr dst, GCPtr pGC, int nInit,
DDXPointPtr pptInit, int *pwidthInit, int sorted)
{
GC_SAVE(pGC);
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("fill spans start ");
if (nInit <= 0) {
pGC->ops->FillSpans(dst, pGC, nInit, pptInit, pwidthInit, sorted);
}
else {
DDXPointPtr ppt = pptInit;
int *pwidth = pwidthInit;
int i = nInit;
BoxRec box;
box.x1 = ppt->x;
box.x2 = box.x1 + *pwidth;
box.y2 = box.y1 = ppt->y;
while (--i) {
ppt++;
pwidth++;
if (box.x1 > ppt->x)
box.x1 = ppt->x;
if (box.x2 < (ppt->x + *pwidth))
box.x2 = ppt->x + *pwidth;
if (box.y1 > ppt->y)
box.y1 = ppt->y;
else if (box.y2 < ppt->y)
box.y2 = ppt->y;
}
box.y2++;
RootlessStartDrawing((WindowPtr) dst);
if (canAccelFill(dst, pGC)) {
GC_UNSET_PM(pGC, dst);
}
pGC->ops->FillSpans(dst, pGC, nInit, pptInit, pwidthInit, sorted);
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
}
GC_RESTORE(pGC, dst);
GCOP_WRAP(pGC);
RL_DEBUG_MSG("fill spans end\n");
}
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);
}
}
static void
ShadowPolyPoint(
DrawablePtr pDraw,
GCPtr pGC,
int mode,
int nptInit,
xPoint *pptInit
){
BoxRec box;
Bool boxNotEmpty = FALSE;
SHADOW_GC_OP_PROLOGUE(pGC);
if(IS_VISIBLE(pDraw) && nptInit) {
xPoint *ppt = pptInit;
int npt = nptInit;
box.x2 = box.x1 = pptInit->x;
box.y2 = box.y1 = pptInit->y;
/* this could be slow if the points were spread out */
while(--npt) {
ppt++;
if(box.x1 > ppt->x) box.x1 = ppt->x;
else if(box.x2 < ppt->x) box.x2 = ppt->x;
if(box.y1 > ppt->y) box.y1 = ppt->y;
else if(box.y2 < ppt->y) box.y2 = ppt->y;
}
box.x2++;
box.y2++;
TRIM_AND_TRANSLATE_BOX(box, pDraw, pGC);
if(BOX_NOT_EMPTY(box)) {
if(pPriv->preRefresh)
(*pPriv->preRefresh)(pPriv->pScrn, 1, &box);
boxNotEmpty = TRUE;
}
}
(*pGC->ops->PolyPoint)(pDraw, pGC, mode, nptInit, pptInit);
if(boxNotEmpty && pPriv->postRefresh)
(*pPriv->postRefresh)(pPriv->pScrn, 1, &box);
SHADOW_GC_OP_EPILOGUE(pGC);
}
static void
RootlessSetSpans(DrawablePtr dst, GCPtr pGC, char *pSrc,
DDXPointPtr pptInit, int *pwidthInit, int nspans, int sorted)
{
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("set spans start ");
if (nspans <= 0) {
pGC->ops->SetSpans(dst, pGC, pSrc, pptInit, pwidthInit, nspans, sorted);
}
else {
DDXPointPtr ppt = pptInit;
int *pwidth = pwidthInit;
int i = nspans;
BoxRec box;
box.x1 = ppt->x;
box.x2 = box.x1 + *pwidth;
box.y2 = box.y1 = ppt->y;
while (--i) {
ppt++;
pwidth++;
if (box.x1 > ppt->x)
box.x1 = ppt->x;
if (box.x2 < (ppt->x + *pwidth))
box.x2 = ppt->x + *pwidth;
if (box.y1 > ppt->y)
box.y1 = ppt->y;
else if (box.y2 < ppt->y)
box.y2 = ppt->y;
}
box.y2++;
RootlessStartDrawing((WindowPtr) dst);
pGC->ops->SetSpans(dst, pGC, pSrc, pptInit, pwidthInit, nspans, sorted);
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
}
GCOP_WRAP(pGC);
RL_DEBUG_MSG("set spans end\n");
}
static RegionPtr
ShadowCopyPlane(
DrawablePtr pSrc,
DrawablePtr pDst,
GCPtr pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty,
unsigned long bitPlane
){
RegionPtr ret;
BoxRec box;
Bool boxNotEmpty = FALSE;
SHADOW_GC_OP_PROLOGUE(pGC);
if(IS_VISIBLE(pDst)) {
box.x1 = dstx + pDst->x;
box.x2 = box.x1 + width;
box.y1 = dsty + pDst->y;
box.y2 = box.y1 + height;
TRIM_BOX(box, pGC);
if(BOX_NOT_EMPTY(box)) {
if(pPriv->preRefresh)
(*pPriv->preRefresh)(pPriv->pScrn, 1, &box);
boxNotEmpty = TRUE;
}
}
ret = (*pGC->ops->CopyPlane)(pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty, bitPlane);
if(boxNotEmpty && pPriv->postRefresh)
(*pPriv->postRefresh)(pPriv->pScrn, 1, &box);
SHADOW_GC_OP_EPILOGUE(pGC);
return ret;
}
/* changed area is *dest* rect */
static RegionPtr
RootlessCopyArea(DrawablePtr pSrc, DrawablePtr dst, GCPtr pGC,
int srcx, int srcy, int w, int h, int dstx, int dsty)
{
RegionPtr result;
BoxRec box;
GC_SAVE(pGC);
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("copy area start (src 0x%x, dst 0x%x)", pSrc, dst);
if (pSrc->type == DRAWABLE_WINDOW && IsFramedWindow((WindowPtr) pSrc)) {
/* If both source and dest are windows, and we're doing
a simple copy operation, we can remove the alpha-protecting
planemask (since source has opaque alpha as well) */
if (canAccelBlit(pSrc, pGC)) {
GC_UNSET_PM(pGC, dst);
}
RootlessStartDrawing((WindowPtr) pSrc);
}
RootlessStartDrawing((WindowPtr) dst);
result = pGC->ops->CopyArea(pSrc, dst, pGC, srcx, srcy, w, h, dstx, dsty);
box.x1 = dstx + dst->x;
box.x2 = box.x1 + w;
box.y1 = dsty + dst->y;
box.y2 = box.y1 + h;
TRIM_BOX(box, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
GC_RESTORE(pGC, dst);
GCOP_WRAP(pGC);
RL_DEBUG_MSG("copy area end\n");
return result;
}
static void
ShadowPolylines(
DrawablePtr pDraw,
GCPtr pGC,
int mode,
int nptInit,
DDXPointPtr pptInit
){
BoxRec box;
Bool boxNotEmpty = FALSE;
SHADOW_GC_OP_PROLOGUE(pGC);
if(IS_VISIBLE(pDraw) && nptInit) {
DDXPointPtr ppt = pptInit;
int npt = nptInit;
int extra = pGC->lineWidth >> 1;
box.x2 = box.x1 = pptInit->x;
box.y2 = box.y1 = pptInit->y;
if(npt > 1) {
if(pGC->joinStyle == JoinMiter)
extra = 6 * pGC->lineWidth;
else if(pGC->capStyle == CapProjecting)
extra = pGC->lineWidth;
}
if(mode == CoordModePrevious) {
int x = box.x1;
int y = box.y1;
while(--npt) {
ppt++;
x += ppt->x;
y += ppt->y;
if(box.x1 > x) box.x1 = x;
else if(box.x2 < x) box.x2 = x;
if(box.y1 > y) box.y1 = y;
else if(box.y2 < y) box.y2 = y;
}
} else {
while(--npt) {
ppt++;
if(box.x1 > ppt->x) box.x1 = ppt->x;
else if(box.x2 < ppt->x) box.x2 = ppt->x;
if(box.y1 > ppt->y) box.y1 = ppt->y;
else if(box.y2 < ppt->y) box.y2 = ppt->y;
}
}
box.x2++;
box.y2++;
if(extra) {
box.x1 -= extra;
box.x2 += extra;
box.y1 -= extra;
box.y2 += extra;
}
TRIM_AND_TRANSLATE_BOX(box, pDraw, pGC);
if(BOX_NOT_EMPTY(box)) {
if(pPriv->preRefresh)
(*pPriv->preRefresh)(pPriv->pScrn, 1, &box);
boxNotEmpty = TRUE;
}
}
/* changed area is box around each line */
static void
RootlessPolylines(DrawablePtr dst, GCPtr pGC,
int mode, int npt, DDXPointPtr pptInit)
{
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("poly lines start ");
RootlessStartDrawing((WindowPtr) dst);
pGC->ops->Polylines(dst, pGC, mode, npt, pptInit);
if (npt > 0) {
BoxRec box;
int extra = pGC->lineWidth >> 1;
box.x2 = box.x1 = pptInit->x;
box.y2 = box.y1 = pptInit->y;
if (npt > 1) {
if (pGC->joinStyle == JoinMiter)
extra = 6 * pGC->lineWidth;
else if (pGC->capStyle == CapProjecting)
extra = pGC->lineWidth;
}
if (mode == CoordModePrevious) {
int x = box.x1;
int y = box.y1;
while (--npt) {
pptInit++;
x += pptInit->x;
y += pptInit->y;
if (box.x1 > x)
box.x1 = x;
else if (box.x2 < x)
box.x2 = x;
if (box.y1 > y)
box.y1 = y;
else if (box.y2 < y)
box.y2 = y;
}
}
else {
while (--npt) {
pptInit++;
if (box.x1 > pptInit->x)
box.x1 = pptInit->x;
else if (box.x2 < pptInit->x)
box.x2 = pptInit->x;
if (box.y1 > pptInit->y)
box.y1 = pptInit->y;
else if (box.y2 < pptInit->y)
box.y2 = pptInit->y;
}
}
box.x2++;
box.y2++;
if (extra) {
box.x1 -= extra;
box.x2 += extra;
box.y1 -= extra;
box.y2 += extra;
}
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
}
/* changed area is box around all points */
static void
RootlessPolyPoint(DrawablePtr dst, GCPtr pGC,
int mode, int npt, DDXPointPtr pptInit)
{
GCOP_UNWRAP(pGC);
RL_DEBUG_MSG("polypoint start ");
RootlessStartDrawing((WindowPtr) dst);
pGC->ops->PolyPoint(dst, pGC, mode, npt, pptInit);
if (npt > 0) {
#if ROOTLESS_CHANGED_AREA==0
// box per point
BoxRec box;
while (npt) {
box.x1 = pptInit->x;
box.y1 = pptInit->y;
box.x2 = box.x1 + 1;
box.y2 = box.y1 + 1;
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
npt--;
pptInit++;
}
#elif ROOTLESS_CHANGED_AREA==1
// one big box
BoxRec box;
box.x2 = box.x1 = pptInit->x;
box.y2 = box.y1 = pptInit->y;
while (--npt) {
pptInit++;
if (box.x1 > pptInit->x)
box.x1 = pptInit->x;
else if (box.x2 < pptInit->x)
box.x2 = pptInit->x;
if (box.y1 > pptInit->y)
box.y1 = pptInit->y;
else if (box.y2 < pptInit->y)
box.y2 = pptInit->y;
}
box.x2++;
box.y2++;
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
#elif ROOTLESS_CHANGED_AREA==2
// clever(?) method: accumulate point in 20-pixel radius
BoxRec box;
int firstx, firsty;
box.x2 = box.x1 = firstx = pptInit->x;
box.y2 = box.y1 = firsty = pptInit->y;
while (--npt) {
pptInit++;
if (abs(pptInit->x - firstx) > 20 || abs(pptInit->y - firsty) > 20) {
box.x2++;
box.y2++;
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
box.x2 = box.x1 = firstx = pptInit->x;
box.y2 = box.y1 = firsty = pptInit->y;
}
else {
if (box.x1 > pptInit->x)
box.x1 = pptInit->x;
else if (box.x2 < pptInit->x)
box.x2 = pptInit->x;
if (box.y1 > pptInit->y)
box.y1 = pptInit->y;
else if (box.y2 < pptInit->y)
box.y2 = pptInit->y;
}
}
box.x2++;
box.y2++;
TRIM_AND_TRANSLATE_BOX(box, dst, pGC);
if (BOX_NOT_EMPTY(box))
RootlessDamageBox((WindowPtr) dst, &box);
#endif /* ROOTLESS_CHANGED_AREA */
}
GCOP_WRAP(pGC);
RL_DEBUG_MSG("polypoint end\n");
}
static void
SMI_Polylines(DrawablePtr pDraw, GCPtr pGC, int mode, int npt,
DDXPointPtr pptInit)
{
XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
ScrnInfoPtr pScrn = infoRec->pScrn;
SMIPtr pSmi = SMIPTR(pScrn);
ENTER_PROC("SMI_Polylines");
/* Call the original Polylines function. */
pGC->ops->Polylines = XAAFallbackOps.Polylines;
(*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
pGC->ops->Polylines = SMI_Polylines;
if (IS_VISIBLE(pDraw) && npt)
{
/* Allocate a temporary buffer for all segments of the polyline. */
BoxPtr pBox = xnfcalloc(sizeof(BoxRec), npt);
int extra = pGC->lineWidth >> 1, box;
if (npt > 1)
{
/* Adjust the extra space required per polyline segment. */
if (pGC->joinStyle == JoinMiter)
{
extra = 6 * pGC->lineWidth;
}
else if (pGC->capStyle == CapProjecting)
{
extra = pGC->lineWidth;
}
}
for (box = 0; --npt;)
{
/* Setup the bounding box for one polyline segment. */
pBox[box].x1 = pptInit->x;
pBox[box].y1 = pptInit->y;
pptInit++;
pBox[box].x2 = pptInit->x;
pBox[box].y2 = pptInit->y;
if (mode == CoordModePrevious)
{
pBox[box].x2 += pBox[box].x1;
pBox[box].y2 += pBox[box].y1;
}
/* Sort coordinates. */
if (pBox[box].x1 > pBox[box].x2)
{
int tmp = pBox[box].x1;
pBox[box].x1 = pBox[box].x2;
pBox[box].x2 = tmp;
}
if (pBox[box].y1 > pBox[box].y2)
{
int tmp = pBox[box].y1;
pBox[box].y1 = pBox[box].y2;
pBox[box].y2 = tmp;
}
/* Add extra space required for each polyline segment. */
pBox[box].x1 -= extra;
pBox[box].y1 -= extra;
pBox[box].x2 += extra + 1;
pBox[box].y2 += extra + 1;
/* See if we need to draw this polyline segment. */
TRANSLATE_BOX(pBox[box], pDraw);
TRIM_BOX(pBox[box], pGC);
if (BOX_NOT_EMPTY(pBox[box]))
{
box++;
}
}
if (box)
{
/* Refresh all polyline segments now. */
SMI_RefreshArea(pScrn, box, pBox);
}
/* Free the temporary buffer. */
xfree(pBox);
}