638 lines
21 KiB
C
638 lines
21 KiB
C
/*
|
|
* 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 GC operations. */
|
|
|
|
#ifdef HAVE_DMX_CONFIG_H
|
|
#include <dmx-config.h>
|
|
#endif
|
|
|
|
#include "dmx.h"
|
|
#include "dmxsync.h"
|
|
#include "dmxgc.h"
|
|
#include "dmxgcops.h"
|
|
#include "dmxwindow.h"
|
|
#include "dmxpixmap.h"
|
|
|
|
#include "mi.h"
|
|
#include "gcstruct.h"
|
|
#include "pixmapstr.h"
|
|
#include "dixfontstr.h"
|
|
|
|
#ifdef PANORAMIX
|
|
#include "panoramiXsrv.h"
|
|
#endif
|
|
|
|
#define DMX_GCOPS_SET_DRAWABLE(_pDraw, _draw) \
|
|
do { \
|
|
if ((_pDraw)->type == DRAWABLE_WINDOW) { \
|
|
dmxWinPrivPtr pWinPriv = \
|
|
DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw)); \
|
|
(_draw) = (Drawable)pWinPriv->window; \
|
|
} else { \
|
|
dmxPixPrivPtr pPixPriv = \
|
|
DMX_GET_PIXMAP_PRIV((PixmapPtr)(_pDraw)); \
|
|
(_draw) = (Drawable)pPixPriv->pixmap; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define DMX_GCOPS_OFFSCREEN(_pDraw) \
|
|
(!dmxScreens[(_pDraw)->pScreen->myNum].beDisplay || \
|
|
(dmxOffScreenOpt && \
|
|
(_pDraw)->type == DRAWABLE_WINDOW && \
|
|
(DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->offscreen || \
|
|
!DMX_GET_WINDOW_PRIV((WindowPtr)(_pDraw))->window)))
|
|
|
|
/** Fill spans -- this function should never be called. */
|
|
void
|
|
dmxFillSpans(DrawablePtr pDrawable, GCPtr pGC,
|
|
int nInit, DDXPointPtr pptInit, int *pwidthInit, int fSorted)
|
|
{
|
|
/* Error -- this should never happen! */
|
|
}
|
|
|
|
/** Set spans -- this function should never be called. */
|
|
void
|
|
dmxSetSpans(DrawablePtr pDrawable, GCPtr pGC,
|
|
char *psrc, DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
|
|
{
|
|
/* Error -- this should never happen! */
|
|
}
|
|
|
|
/** Transfer \a pBits image to back-end server associated with \a
|
|
* pDrawable's screen. If primitive subdivision optimization is
|
|
* enabled, then only transfer the sections of \a pBits that are
|
|
* visible (i.e., not-clipped) to the back-end server. */
|
|
void
|
|
dmxPutImage(DrawablePtr pDrawable, GCPtr pGC,
|
|
int depth, int x, int y, int w, int h,
|
|
int leftPad, int format, char *pBits)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
XImage *img;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
img = XCreateImage(dmxScreen->beDisplay,
|
|
dmxScreen->beVisuals[dmxScreen->beDefVisualIndex].visual,
|
|
depth, format, leftPad, pBits, w, h,
|
|
BitmapPad(dmxScreen->beDisplay),
|
|
(format == ZPixmap) ?
|
|
PixmapBytePad(w, depth) : BitmapBytePad(w + leftPad));
|
|
|
|
if (img) {
|
|
Drawable draw;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
if (dmxSubdividePrimitives && pGC->pCompositeClip) {
|
|
RegionPtr pSubImages;
|
|
RegionPtr pClip;
|
|
BoxRec box;
|
|
BoxPtr pBox;
|
|
int nBox;
|
|
|
|
box.x1 = x;
|
|
box.y1 = y;
|
|
box.x2 = x + w;
|
|
box.y2 = y + h;
|
|
pSubImages = RegionCreate(&box, 1);
|
|
|
|
pClip = RegionCreate(NullBox, 1);
|
|
RegionCopy(pClip, pGC->pCompositeClip);
|
|
RegionTranslate(pClip, -pDrawable->x, -pDrawable->y);
|
|
RegionIntersect(pSubImages, pSubImages, pClip);
|
|
|
|
nBox = RegionNumRects(pSubImages);
|
|
pBox = RegionRects(pSubImages);
|
|
|
|
while (nBox--) {
|
|
XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc, img,
|
|
pBox->x1 - box.x1,
|
|
pBox->y1 - box.y1,
|
|
pBox->x1,
|
|
pBox->y1, pBox->x2 - pBox->x1, pBox->y2 - pBox->y1);
|
|
pBox++;
|
|
}
|
|
RegionDestroy(pClip);
|
|
RegionDestroy(pSubImages);
|
|
}
|
|
else {
|
|
XPutImage(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
img, 0, 0, x, y, w, h);
|
|
}
|
|
XFree(img); /* Use XFree instead of XDestroyImage
|
|
* because pBits is passed in from the
|
|
* caller. */
|
|
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
else {
|
|
/* Error -- this should not happen! */
|
|
}
|
|
}
|
|
|
|
/** Copy area from \a pSrc drawable to \a pDst drawable on the back-end
|
|
* server associated with \a pSrc drawable's screen. If the offscreen
|
|
* optimization is enabled, only copy when both \a pSrc and \a pDst are
|
|
* at least partially visible. */
|
|
RegionPtr
|
|
dmxCopyArea(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
|
|
int srcx, int srcy, int w, int h, int dstx, int dsty)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable srcDraw, dstDraw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
|
|
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h,
|
|
dstx, dsty, 0L);
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
|
|
DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
|
|
|
|
XCopyArea(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
|
|
srcx, srcy, w, h, dstx, dsty);
|
|
dmxSync(dmxScreen, FALSE);
|
|
|
|
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, 0L);
|
|
}
|
|
|
|
/** Copy plane number \a bitPlane from \a pSrc drawable to \a pDst
|
|
* drawable on the back-end server associated with \a pSrc drawable's
|
|
* screen. If the offscreen optimization is enabled, only copy when
|
|
* both \a pSrc and \a pDst are at least partially visible. */
|
|
RegionPtr
|
|
dmxCopyPlane(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
|
|
int srcx, int srcy, int width, int height,
|
|
int dstx, int dsty, unsigned long bitPlane)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pSrc->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable srcDraw, dstDraw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pSrc) || DMX_GCOPS_OFFSCREEN(pDst))
|
|
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
|
|
dstx, dsty, bitPlane);
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pSrc, srcDraw);
|
|
DMX_GCOPS_SET_DRAWABLE(pDst, dstDraw);
|
|
|
|
XCopyPlane(dmxScreen->beDisplay, srcDraw, dstDraw, pGCPriv->gc,
|
|
srcx, srcy, width, height, dstx, dsty, bitPlane);
|
|
dmxSync(dmxScreen, FALSE);
|
|
|
|
return miHandleExposures(pSrc, pDst, pGC, srcx, srcy, width, height,
|
|
dstx, dsty, bitPlane);
|
|
}
|
|
|
|
/** Render list of points, \a pptInit in \a pDrawable on the back-end
|
|
* server associated with \a pDrawable's screen. If the offscreen
|
|
* optimization is enabled, only draw when \a pDrawable is at least
|
|
* partially visible. */
|
|
void
|
|
dmxPolyPoint(DrawablePtr pDrawable, GCPtr pGC,
|
|
int mode, int npt, DDXPointPtr pptInit)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawPoints(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
(XPoint *) pptInit, npt, mode);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render list of connected lines, \a pptInit in \a pDrawable on the
|
|
* back-end server associated with \a pDrawable's screen. If the
|
|
* offscreen optimization is enabled, only draw when \a pDrawable is at
|
|
* least partially visible. */
|
|
void
|
|
dmxPolylines(DrawablePtr pDrawable, GCPtr pGC,
|
|
int mode, int npt, DDXPointPtr pptInit)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawLines(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
(XPoint *) pptInit, npt, mode);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render list of disjoint segments, \a pSegs in \a pDrawable on the
|
|
* back-end server associated with \a pDrawable's screen. If the
|
|
* offscreen optimization is enabled, only draw when \a pDrawable is at
|
|
* least partially visible. */
|
|
void
|
|
dmxPolySegment(DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment * pSegs)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawSegments(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
(XSegment *) pSegs, nseg);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render list of rectangle outlines, \a pRects in \a pDrawable on the
|
|
* back-end server associated with \a pDrawable's screen. If the
|
|
* offscreen optimization is enabled, only draw when \a pDrawable is at
|
|
* least partially visible. */
|
|
void
|
|
dmxPolyRectangle(DrawablePtr pDrawable, GCPtr pGC,
|
|
int nrects, xRectangle *pRects)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
(XRectangle *) pRects, nrects);
|
|
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render list of arc outlines, \a parcs in \a pDrawable on the
|
|
* back-end server associated with \a pDrawable's screen. If the
|
|
* offscreen optimization is enabled, only draw when \a pDrawable is at
|
|
* least partially visible. */
|
|
void
|
|
dmxPolyArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * parcs)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawArcs(dmxScreen->beDisplay, draw, pGCPriv->gc, (XArc *) parcs, narcs);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render a filled polygons in \a pDrawable on the back-end server
|
|
* associated with \a pDrawable's screen. If the offscreen
|
|
* optimization is enabled, only draw when \a pDrawable is at least
|
|
* partially visible. */
|
|
void
|
|
dmxFillPolygon(DrawablePtr pDrawable, GCPtr pGC,
|
|
int shape, int mode, int count, DDXPointPtr pPts)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XFillPolygon(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
(XPoint *) pPts, count, shape, mode);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render list of filled rectangles, \a prectInit in \a pDrawable on
|
|
* the back-end server associated with \a pDrawable's screen. If the
|
|
* offscreen optimization is enabled, only draw when \a pDrawable is at
|
|
* least partially visible. */
|
|
void
|
|
dmxPolyFillRect(DrawablePtr pDrawable, GCPtr pGC,
|
|
int nrectFill, xRectangle *prectInit)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XFillRectangles(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
(XRectangle *) prectInit, nrectFill);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render list of filled arcs, \a parcs in \a pDrawable on the back-end
|
|
* server associated with \a pDrawable's screen. If the offscreen
|
|
* optimization is enabled, only draw when \a pDrawable is at least
|
|
* partially visible. */
|
|
void
|
|
dmxPolyFillArc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * parcs)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XFillArcs(dmxScreen->beDisplay, draw, pGCPriv->gc, (XArc *) parcs, narcs);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render string of 8-bit \a chars (foreground only) in \a pDrawable on
|
|
* the back-end server associated with \a pDrawable's screen. If the
|
|
* offscreen optimization is enabled, only draw when \a pDrawable is at
|
|
* least partially visible. */
|
|
int
|
|
dmxPolyText8(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, int count, char *chars)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
unsigned long n, i;
|
|
int w;
|
|
CharInfoPtr charinfo[255];
|
|
Drawable draw;
|
|
|
|
GetGlyphs(pGC->font, (unsigned long) count, (unsigned char *) chars,
|
|
Linear8Bit, &n, charinfo);
|
|
|
|
/* Calculate text width */
|
|
w = 0;
|
|
for (i = 0; i < n; i++)
|
|
w += charinfo[i]->metrics.characterWidth;
|
|
|
|
if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawString(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
x, y, chars, count);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
return x + w;
|
|
}
|
|
|
|
/** Render string of 16-bit \a chars (foreground only) in \a pDrawable
|
|
* on the back-end server associated with \a pDrawable's screen. If
|
|
* the offscreen optimization is enabled, only draw when \a pDrawable
|
|
* is at least partially visible. */
|
|
int
|
|
dmxPolyText16(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, int count, unsigned short *chars)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
unsigned long n, i;
|
|
int w;
|
|
CharInfoPtr charinfo[255];
|
|
Drawable draw;
|
|
|
|
GetGlyphs(pGC->font, (unsigned long) count, (unsigned char *) chars,
|
|
(FONTLASTROW(pGC->font) == 0) ? Linear16Bit : TwoD16Bit,
|
|
&n, charinfo);
|
|
|
|
/* Calculate text width */
|
|
w = 0;
|
|
for (i = 0; i < n; i++)
|
|
w += charinfo[i]->metrics.characterWidth;
|
|
|
|
if (n != 0 && !DMX_GCOPS_OFFSCREEN(pDrawable)) {
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
x, y, (XChar2b *) chars, count);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
return x + w;
|
|
}
|
|
|
|
/** Render string of 8-bit \a chars (both foreground and background) in
|
|
* \a pDrawable on the back-end server associated with \a pDrawable's
|
|
* screen. If the offscreen optimization is enabled, only draw when \a
|
|
* pDrawable is at least partially visible. */
|
|
void
|
|
dmxImageText8(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, int count, char *chars)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawImageString(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
x, y, chars, count);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Render string of 16-bit \a chars (both foreground and background) in
|
|
* \a pDrawable on the back-end server associated with \a pDrawable's
|
|
* screen. If the offscreen optimization is enabled, only draw when \a
|
|
* pDrawable is at least partially visible. */
|
|
void
|
|
dmxImageText16(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, int count, unsigned short *chars)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
dmxGCPrivPtr pGCPriv = DMX_GET_GC_PRIV(pGC);
|
|
Drawable draw;
|
|
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable))
|
|
return;
|
|
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
|
|
XDrawImageString16(dmxScreen->beDisplay, draw, pGCPriv->gc,
|
|
x, y, (XChar2b *) chars, count);
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Image Glyph Blt -- this function should never be called. */
|
|
void
|
|
dmxImageGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, unsigned int nglyph,
|
|
CharInfoPtr * ppci, pointer pglyphBase)
|
|
{
|
|
/* Error -- this should never happen! */
|
|
}
|
|
|
|
/** Poly Glyph Blt -- this function should never be called. */
|
|
void
|
|
dmxPolyGlyphBlt(DrawablePtr pDrawable, GCPtr pGC,
|
|
int x, int y, unsigned int nglyph,
|
|
CharInfoPtr * ppci, pointer pglyphBase)
|
|
{
|
|
/* Error -- this should never happen! */
|
|
}
|
|
|
|
/** Push Pixels -- this function should never be called. */
|
|
void
|
|
dmxPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDst,
|
|
int w, int h, int x, int y)
|
|
{
|
|
/* Error -- this should never happen! */
|
|
}
|
|
|
|
/**********************************************************************
|
|
* Miscellaneous drawing commands
|
|
*/
|
|
|
|
/** When Xinerama is active, the client pixmaps are always obtained from
|
|
* screen 0. When screen 0 is detached, the pixmaps must be obtained
|
|
* from any other screen that is not detached. Usually, this is screen
|
|
* 1. */
|
|
static DMXScreenInfo *
|
|
dmxFindAlternatePixmap(DrawablePtr pDrawable, XID *draw)
|
|
{
|
|
#ifdef PANORAMIX
|
|
PanoramiXRes *pXinPix;
|
|
int i;
|
|
DMXScreenInfo *dmxScreen;
|
|
|
|
if (noPanoramiXExtension)
|
|
return NULL;
|
|
if (pDrawable->type != DRAWABLE_PIXMAP)
|
|
return NULL;
|
|
|
|
if (Success != dixLookupResourceByType((pointer *) &pXinPix,
|
|
pDrawable->id, XRT_PIXMAP,
|
|
NullClient, DixUnknownAccess))
|
|
return NULL;
|
|
|
|
FOR_NSCREENS_FORWARD_SKIP(i) {
|
|
dmxScreen = &dmxScreens[i];
|
|
if (dmxScreen->beDisplay) {
|
|
PixmapPtr pSrc;
|
|
dmxPixPrivPtr pSrcPriv;
|
|
|
|
dixLookupResourceByType((pointer *) &pSrc, pXinPix->info[i].id,
|
|
RT_PIXMAP, NullClient, DixUnknownAccess);
|
|
pSrcPriv = DMX_GET_PIXMAP_PRIV(pSrc);
|
|
if (pSrcPriv->pixmap) {
|
|
*draw = pSrcPriv->pixmap;
|
|
return dmxScreen;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
/** Get an image from the back-end server associated with \a pDrawable's
|
|
* screen. If \a pDrawable is a window, it must be viewable to get an
|
|
* image from it. If it is not viewable, then get the image from the
|
|
* first ancestor of \a pDrawable that is viewable. If no viewable
|
|
* ancestor is found, then simply return without getting an image. */
|
|
void
|
|
dmxGetImage(DrawablePtr pDrawable, int sx, int sy, int w, int h,
|
|
unsigned int format, unsigned long planeMask, char *pdstLine)
|
|
{
|
|
DMXScreenInfo *dmxScreen = &dmxScreens[pDrawable->pScreen->myNum];
|
|
XImage *img;
|
|
Drawable draw;
|
|
|
|
/* Cannot get image from unviewable window */
|
|
if (pDrawable->type == DRAWABLE_WINDOW) {
|
|
WindowPtr pWindow = (WindowPtr) pDrawable;
|
|
|
|
if (!pWindow->viewable) {
|
|
while (!pWindow->viewable && pWindow->parent) {
|
|
sx += pWindow->origin.x - wBorderWidth(pWindow);
|
|
sx += pWindow->origin.y - wBorderWidth(pWindow);
|
|
pWindow = pWindow->parent;
|
|
}
|
|
if (!pWindow->viewable) {
|
|
return;
|
|
}
|
|
}
|
|
DMX_GCOPS_SET_DRAWABLE(&pWindow->drawable, draw);
|
|
if (DMX_GCOPS_OFFSCREEN(&pWindow->drawable))
|
|
return;
|
|
}
|
|
else {
|
|
DMX_GCOPS_SET_DRAWABLE(pDrawable, draw);
|
|
if (DMX_GCOPS_OFFSCREEN(pDrawable)) {
|
|
/* Try to find the pixmap on a non-detached Xinerama screen */
|
|
dmxScreen = dmxFindAlternatePixmap(pDrawable, &draw);
|
|
if (!dmxScreen)
|
|
return;
|
|
}
|
|
}
|
|
|
|
img = XGetImage(dmxScreen->beDisplay, draw,
|
|
sx, sy, w, h, planeMask, format);
|
|
if (img) {
|
|
int len = img->bytes_per_line * img->height;
|
|
|
|
memmove(pdstLine, img->data, len);
|
|
XDestroyImage(img);
|
|
}
|
|
|
|
dmxSync(dmxScreen, FALSE);
|
|
}
|
|
|
|
/** Get Spans -- this function should never be called. */
|
|
void
|
|
dmxGetSpans(DrawablePtr pDrawable, int wMax,
|
|
DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
|
|
{
|
|
/* Error -- this should never happen! */
|
|
}
|