/* * Copyright 2001-2004 Red Hat Inc., Durham, North Carolina. * * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation on the rights to use, copy, modify, merge, * publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, * subject to the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial * portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ /* * Authors: * Kevin E. Martin <kem@redhat.com> * */ /** \file * This file provides support for GCs. */ #ifdef HAVE_DMX_CONFIG_H #include <dmx-config.h> #endif #include "dmx.h" #include "dmxsync.h" #include "dmxgc.h" #include "dmxgcops.h" #include "dmxpixmap.h" #include "dmxfont.h" #include "gcstruct.h" #include "pixmapstr.h" #include "migc.h" static GCFuncs dmxGCFuncs = { dmxValidateGC, dmxChangeGC, dmxCopyGC, dmxDestroyGC, dmxChangeClip, dmxDestroyClip, dmxCopyClip, }; static GCOps dmxGCOps = { dmxFillSpans, dmxSetSpans, dmxPutImage, dmxCopyArea, dmxCopyPlane, dmxPolyPoint, dmxPolylines, dmxPolySegment, dmxPolyRectangle, dmxPolyArc, dmxFillPolygon, dmxPolyFillRect, dmxPolyFillArc, dmxPolyText8, dmxPolyText16, dmxImageText8, dmxImageText16, dmxImageGlyphBlt, dmxPolyGlyphBlt, dmxPushPixels }; /** Initialize the GC on \a pScreen */ Bool dmxInitGC(ScreenPtr pScreen) { if (!dixRegisterPrivateKey(&dmxGCPrivateKeyRec, PRIVATE_GC, sizeof(dmxGCPrivRec))) return FALSE; return TRUE; } /** Create the GC on the back-end server. */ void dmxBECreateGC(ScreenPtr pScreen, GCPtr pGC) { DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); int i; for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) { if (pGC->depth == dmxScreen->bePixmapFormats[i].depth) { unsigned long mask; XGCValues gcvals; mask = GCGraphicsExposures; gcvals.graphics_exposures = FALSE; /* Create GC in the back-end servers */ pGCPriv->gc = XCreateGC(dmxScreen->beDisplay, dmxScreen->scrnDefDrawables[i], mask, &gcvals); break; } } } /** 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; } /** Validate a graphics context, \a pGC, locally in the DMX server and * recompute the composite clip, if necessary. */ void dmxValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); DMX_GC_FUNC_PROLOGUE(pGC); #if 0 pGC->funcs->ValidateGC(pGC, changes, pDrawable); #endif if (pDrawable->type == DRAWABLE_WINDOW || pDrawable->type == DRAWABLE_PIXMAP) { /* Save the old ops, since we're about to change the ops in the * epilogue. */ pGCPriv->ops = pGC->ops; } else { pGCPriv->ops = NULL; } /* If the client clip is different or moved OR the subwindowMode has * changed OR the window's clip has changed since the last * validation, then we need to recompute the composite clip. */ if ((changes & (GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode)) || (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))) { miComputeCompositeClip(pGC, pDrawable); } DMX_GC_FUNC_EPILOGUE(pGC); } /** Set the values in the graphics context on the back-end server * associated with \a pGC's screen. */ void dmxChangeGC(GCPtr pGC, unsigned long mask) { ScreenPtr pScreen = pGC->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); XGCValues v; DMX_GC_FUNC_PROLOGUE(pGC); #if 0 pGC->funcs->ChangeGC(pGC, mask); #endif /* Handle "magic special case" from CreateGC */ if (pGCPriv->msc) { /* The "magic special case" is used to handle the case where a * foreground pixel is set when the GC is created so that a * "pseudo default-tile" can be created and used in case the * fillstyle was set to FillTiled. This specific case is tested * in xtest (XCreateGC test #3). What has happened in dix by * the time it reaches here is (1) the pGC->tile.pixel has been * set to pGC->fgPixel and pGC->tileIsPixel is set, (2) if a * tile has also been set, then pGC->tileIsPixel is unset and * pGC->tile.pixmap is initialized; else, the default tile is * created and pGC->tileIsPixel is unset and pGC->tile.pixmap is * initialized to the "pseudo default-tile". In either case, * pGC->tile.pixmap is set; however, in the "magic special case" * the mask is not updated to allow us to detect that we should * initialize the GCTile in the back-end server. Thus, we catch * this case in dmxCreateGC and add GCTile to the mask here. * Are there any cases that I've missed? */ /* Make sure that the tile.pixmap is set, just in case the user * set GCTile in the mask but forgot to set vals.pixmap */ if (pGC->tile.pixmap) mask |= GCTile; /* This only happens once when the GC is created */ pGCPriv->msc = FALSE; } /* Update back-end server's gc */ if (mask & GCFunction) v.function = pGC->alu; if (mask & GCPlaneMask) v.plane_mask = pGC->planemask; if (mask & GCForeground) v.foreground = pGC->fgPixel; if (mask & GCBackground) v.background = pGC->bgPixel; if (mask & GCLineWidth) v.line_width = pGC->lineWidth; if (mask & GCLineStyle) v.line_style = pGC->lineStyle; if (mask & GCCapStyle) v.cap_style = pGC->capStyle; if (mask & GCJoinStyle) v.join_style = pGC->joinStyle; if (mask & GCFillStyle) v.fill_style = pGC->fillStyle; if (mask & GCFillRule) v.fill_rule = pGC->fillRule; if (mask & GCTile) { if (pGC->tileIsPixel) { mask &= ~GCTile; } else { dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pGC->tile.pixmap); v.tile = (Drawable)pPixPriv->pixmap; } } if (mask & GCStipple) { dmxPixPrivPtr pPixPriv = DMX_GET_PIXMAP_PRIV(pGC->stipple); v.stipple = (Drawable)pPixPriv->pixmap; } if (mask & GCTileStipXOrigin) v.ts_x_origin = pGC->patOrg.x; if (mask & GCTileStipYOrigin) v.ts_y_origin = pGC->patOrg.y; if (mask & GCFont) { if (dmxScreen->beDisplay) { dmxFontPrivPtr pFontPriv; pFontPriv = FontGetPrivate(pGC->font, dmxFontPrivateIndex); v.font = pFontPriv->font[pScreen->myNum]->fid; } else { mask &= ~GCFont; } } if (mask & GCSubwindowMode) v.subwindow_mode = pGC->subWindowMode; /* Graphics exposures are not needed on the back-ends since they can be generated on the front-end thereby saving bandwidth. */ if (mask & GCGraphicsExposures) mask &= ~GCGraphicsExposures; if (mask & GCClipXOrigin) v.clip_x_origin = pGC->clipOrg.x; if (mask & GCClipYOrigin) v.clip_y_origin = pGC->clipOrg.y; if (mask & GCClipMask) mask &= ~GCClipMask; /* See ChangeClip */ if (mask & GCDashOffset) v.dash_offset = pGC->dashOffset; if (mask & GCDashList) { mask &= ~GCDashList; if (dmxScreen->beDisplay) XSetDashes(dmxScreen->beDisplay, pGCPriv->gc, pGC->dashOffset, (char *)pGC->dash, pGC->numInDashList); } if (mask & GCArcMode) v.arc_mode = pGC->arcMode; if (mask && dmxScreen->beDisplay) { XChangeGC(dmxScreen->beDisplay, pGCPriv->gc, mask, &v); dmxSync(dmxScreen, FALSE); } DMX_GC_FUNC_EPILOGUE(pGC); } /** Copy \a pGCSrc to \a pGCDst on the back-end server associated with * \a pGCSrc's screen. */ void dmxCopyGC(GCPtr pGCSrc, unsigned long changes, GCPtr pGCDst) { ScreenPtr pScreen = pGCSrc->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCSrcPriv = DMX_GET_GC_PRIV(pGCSrc); dmxGCPrivPtr pGCDstPriv = DMX_GET_GC_PRIV(pGCDst); DMX_GC_FUNC_PROLOGUE(pGCDst); pGCDst->funcs->CopyGC(pGCSrc, changes, pGCDst); /* Copy the GC on the back-end server */ if (dmxScreen->beDisplay) XCopyGC(dmxScreen->beDisplay, pGCSrcPriv->gc, changes, pGCDstPriv->gc); DMX_GC_FUNC_EPILOGUE(pGCDst); } /** Free the \a pGC on the back-end server. */ Bool dmxBEFreeGC(GCPtr pGC) { ScreenPtr pScreen = pGC->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); if (pGCPriv->gc) { XFreeGC(dmxScreen->beDisplay, pGCPriv->gc); pGCPriv->gc = NULL; return TRUE; } return FALSE; } /** Destroy the graphics context, \a pGC and free the corresponding GC * on the back-end server. */ void dmxDestroyGC(GCPtr pGC) { ScreenPtr pScreen = pGC->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; DMX_GC_FUNC_PROLOGUE(pGC); /* Free the GC on the back-end server */ if (dmxScreen->beDisplay) dmxBEFreeGC(pGC); pGC->funcs->DestroyGC(pGC); DMX_GC_FUNC_EPILOGUE(pGC); } /** Change the clip rects for a GC. */ void dmxChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects) { ScreenPtr pScreen = pGC->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); XRectangle *pRects; BoxPtr pBox; int i, nRects; DMX_GC_FUNC_PROLOGUE(pGC); pGC->funcs->ChangeClip(pGC, type, pvalue, nrects); /* Set the client clip on the back-end server */ switch (pGC->clientClipType) { case CT_NONE: if (dmxScreen->beDisplay) XSetClipMask(dmxScreen->beDisplay, pGCPriv->gc, None); break; case CT_REGION: if (dmxScreen->beDisplay) { nRects = RegionNumRects((RegionPtr)pGC->clientClip); pRects = malloc(nRects * sizeof(*pRects)); pBox = RegionRects((RegionPtr)pGC->clientClip); for (i = 0; i < nRects; i++) { pRects[i].x = pBox[i].x1; pRects[i].y = pBox[i].y1; pRects[i].width = pBox[i].x2 - pBox[i].x1; pRects[i].height = pBox[i].y2 - pBox[i].y1; } XSetClipRectangles(dmxScreen->beDisplay, pGCPriv->gc, pGC->clipOrg.x, pGC->clipOrg.y, pRects, nRects, Unsorted); free(pRects); } break; case CT_PIXMAP: /* Condensed down to REGION in the mi code */ break; } DMX_GC_FUNC_EPILOGUE(pGC); } /** Destroy a GC's clip rects. */ void dmxDestroyClip(GCPtr pGC) { ScreenPtr pScreen = pGC->pScreen; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC); DMX_GC_FUNC_PROLOGUE(pGC); pGC->funcs->DestroyClip(pGC); /* Set the client clip on the back-end server to None */ if (dmxScreen->beDisplay) XSetClipMask(dmxScreen->beDisplay, pGCPriv->gc, None); DMX_GC_FUNC_EPILOGUE(pGC); } /** Copy a GC's clip rects. */ void dmxCopyClip(GCPtr pGCDst, GCPtr pGCSrc) { DMX_GC_FUNC_PROLOGUE(pGCDst); pGCDst->funcs->CopyClip(pGCDst, pGCSrc); DMX_GC_FUNC_EPILOGUE(pGCDst); }