andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
0ff273fd1e
xserver-multidpi/hw/xfree86/rac/xf86RAC.c
Adam Jackson ae7f71a8b3 Implement core protocol backing store exclusively in terms of Composite. 
Composite's automatic redirection is a more general mechanism than the
ad-hoc BS machinery, so it's much prettier to implement the one in terms
of the other.  Composite now wraps ChangeWindowAttributes and activates
automatic redirection for windows with backing store requested.  The old
backing store infrastructure is completely gutted: ABI-visible structures
retain the function pointers, but they never get called, and all the
open-coded conditionals throughout the DIX layer to implement BS are gone.

Note that this is still not a strictly complete implementation of backing
store, since Composite will throw the bits away on unmap and therefore
WhenMapped and Always hints are equivalent.
2007-08-25 15:08:20 -04:00

1207 lines
31 KiB
C
Raw Blame History

#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "misc.h"
#include "xf86.h"
#include "xf86_OSproc.h"
#include <X11/X.h>
#include "colormapst.h"
#include "scrnintstr.h"
#include "screenint.h"
#include "gcstruct.h"
#include "pixmapstr.h"
#include "pixmap.h"
#include "windowstr.h"
#include "window.h"
#include "xf86str.h"
#include "xf86RAC.h"
#include "mipointer.h"
#include "mipointrst.h"
#ifdef RENDER
# include "picturestr.h"
#endif
#ifdef DEBUG
#define DPRINT_S(x,y) ErrorF(x ": %i\n",y);
#define DPRINT(x) ErrorF(x "\n");
#else
#define DPRINT_S(x,y)
#define DPRINT(x)
#endif
#define WRAP_SCREEN(x,y) {pScreenPriv->x = pScreen->x;\
pScreen->x = y;}
#define WRAP_SCREEN_COND(x,y,cond) \
{pScreenPriv->x = pScreen->x;\
if (flag & (cond))\
pScreen->x = y;}
#define UNWRAP_SCREEN(x) pScreen->x = pScreenPriv->x
#define SCREEN_PROLOG(x) \
pScreen->x = \
((RACScreenPtr) (pScreen)->devPrivates[RACScreenIndex].ptr)->x
#define SCREEN_EPILOG(x,y) pScreen->x = y;
#define WRAP_PICT_COND(x,y,cond) if (ps)\
{pScreenPriv->x = ps->x;\
if (flag & (cond))\
ps->x = y;}
#define UNWRAP_PICT(x) if (ps) {ps->x = pScreenPriv->x;}
#define PICTURE_PROLOGUE(field) \
ps->field = \
((RACScreenPtr) (pScreen)->devPrivates[RACScreenIndex].ptr)->field
#define PICTURE_EPILOGUE(field, wrap) \
ps->field = wrap
#define WRAP_SCREEN_INFO(x,y) {pScreenPriv->x = pScrn->x;\
pScrn->x = y;}
#define WRAP_SCREEN_INFO_COND(x,y,cond) \
{pScreenPriv->x = pScrn->x;\
if (flag & (cond))\
pScrn->x = y;}
#define UNWRAP_SCREEN_INFO(x) pScrn->x = pScreenPriv->x
#define SPRITE_PROLOG miPointerScreenPtr PointPriv = \
(miPointerScreenPtr)pScreen->devPrivates[miPointerScreenIndex].ptr;\
RACScreenPtr pScreenPriv = \
((RACScreenPtr) (pScreen)->devPrivates[RACScreenIndex].ptr);\
PointPriv->spriteFuncs = pScreenPriv->miSprite;
#define SPRITE_EPILOG pScreenPriv->miSprite = PointPriv->spriteFuncs;\
PointPriv->spriteFuncs = &RACSpriteFuncs;
#define WRAP_SPRITE_COND(cond){pScreenPriv->miSprite = PointPriv->spriteFuncs;\
if(flag & (cond))\
PointPriv->spriteFuncs = &RACSpriteFuncs;}
#define UNWRAP_SPRITE PointPriv->spriteFuncs = pScreenPriv->miSprite
#define GC_WRAP(x) pGCPriv->wrapOps = (x)->ops;\
pGCPriv->wrapFuncs = (x)->funcs;\
(x)->ops = &RACGCOps;\
(x)->funcs = &RACGCFuncs;
#define GC_UNWRAP(x)\
RACGCPtr pGCPriv = (RACGCPtr) (x)->devPrivates[RACGCIndex].ptr;\
(x)->ops = pGCPriv->wrapOps;\
(x)->funcs = pGCPriv->wrapFuncs;
#define GC_SCREEN register ScrnInfoPtr pScrn \
= xf86Screens[pGC->pScreen->myNum]
#define ENABLE xf86EnableAccess(xf86Screens[pScreen->myNum])
#define ENABLE_GC xf86EnableAccess(xf86Screens[pGC->pScreen->myNum])
typedef struct _RACScreen {
CreateGCProcPtr CreateGC;
CloseScreenProcPtr CloseScreen;
GetImageProcPtr GetImage;
GetSpansProcPtr GetSpans;
SourceValidateProcPtr SourceValidate;
PaintWindowBackgroundProcPtr PaintWindowBackground;
PaintWindowBorderProcPtr PaintWindowBorder;
CopyWindowProcPtr CopyWindow;
ClearToBackgroundProcPtr ClearToBackground;
CreatePixmapProcPtr CreatePixmap;
SaveScreenProcPtr SaveScreen;
/* Colormap */
StoreColorsProcPtr StoreColors;
/* Cursor */
DisplayCursorProcPtr DisplayCursor;
RealizeCursorProcPtr RealizeCursor;
UnrealizeCursorProcPtr UnrealizeCursor;
RecolorCursorProcPtr RecolorCursor;
SetCursorPositionProcPtr SetCursorPosition;
void (*AdjustFrame)(int,int,int,int);
Bool (*SwitchMode)(int, DisplayModePtr,int);
Bool (*EnterVT)(int, int);
void (*LeaveVT)(int, int);
void (*FreeScreen)(int, int);
miPointerSpriteFuncPtr miSprite;
#ifdef RENDER
CompositeProcPtr Composite;
GlyphsProcPtr Glyphs;
CompositeRectsProcPtr CompositeRects;
#endif
} RACScreenRec, *RACScreenPtr;
typedef struct _RACGC {
GCOps *wrapOps;
GCFuncs *wrapFuncs;
} RACGCRec, *RACGCPtr;
/* Screen funcs */
static Bool RACCloseScreen (int i, ScreenPtr pScreen);
static void RACGetImage (DrawablePtr pDrawable, int sx, int sy,
int w, int h, unsigned int format,
unsigned long planemask, char *pdstLine);
static void RACGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
int *pwidth, int nspans, char *pdstStart);
static void RACSourceValidate (DrawablePtr pDrawable,
int x, int y, int width, int height );
static void RACPaintWindowBackground(WindowPtr pWin, RegionPtr prgn, int what);
static void RACPaintWindowBorder(WindowPtr pWin, RegionPtr prgn, int what);
static void RACCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg,
RegionPtr prgnSrc );
static void RACClearToBackground (WindowPtr pWin, int x, int y,
int w, int h, Bool generateExposures );
static PixmapPtr RACCreatePixmap(ScreenPtr pScreen, int w, int h, int depth);
static Bool RACCreateGC(GCPtr pGC);
static Bool RACSaveScreen(ScreenPtr pScreen, Bool unblank);
static void RACStoreColors (ColormapPtr pmap, int ndef, xColorItem *pdefs);
static void RACRecolorCursor (ScreenPtr pScreen, CursorPtr pCurs,
Bool displayed);
static Bool RACRealizeCursor (ScreenPtr pScreen, CursorPtr pCursor);
static Bool RACUnrealizeCursor (ScreenPtr pScreen, CursorPtr pCursor);
static Bool RACDisplayCursor (ScreenPtr pScreen, CursorPtr pCursor);
static Bool RACSetCursorPosition (ScreenPtr pScreen, int x, int y,
Bool generateEvent);
static void RACAdjustFrame(int index, int x, int y, int flags);
static Bool RACSwitchMode(int index, DisplayModePtr mode, int flags);
static Bool RACEnterVT(int index, int flags);
static void RACLeaveVT(int index, int flags);
static void RACFreeScreen(int index, int flags);
/* GC funcs */
static void RACValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDraw);
static void RACChangeGC(GCPtr pGC, unsigned long mask);
static void RACCopyGC(GCPtr pGCSrc, unsigned long mask, GCPtr pGCDst);
static void RACDestroyGC(GCPtr pGC);
static void RACChangeClip(GCPtr pGC, int type, pointer pvalue, int nrects);
static void RACDestroyClip(GCPtr pGC);
static void RACCopyClip(GCPtr pgcDst, GCPtr pgcSrc);
/* GC ops */
static void RACFillSpans( DrawablePtr pDraw, GC *pGC, int nInit,
DDXPointPtr pptInit, int *pwidthInit, int fSorted );
static void RACSetSpans(DrawablePtr pDraw, GCPtr pGC, char *pcharsrc,
register DDXPointPtr ppt, int *pwidth, int nspans,
int fSorted );
static void RACPutImage(DrawablePtr pDraw, GCPtr pGC, int depth,
int x, int y, int w, int h, int leftPad,
int format, char *pImage );
static RegionPtr RACCopyArea(DrawablePtr pSrc, DrawablePtr pDst,
GC *pGC, int srcx, int srcy,
int width, int height,
int dstx, int dsty );
static RegionPtr RACCopyPlane(DrawablePtr pSrc, DrawablePtr pDst,
GCPtr pGC, int srcx, int srcy,
int width, int height, int dstx, int dsty,
unsigned long bitPlane );
static void RACPolyPoint(DrawablePtr pDraw, GCPtr pGC, int mode,
int npt, xPoint *pptInit );
static void RACPolylines(DrawablePtr pDraw, GCPtr pGC, int mode,
int npt, DDXPointPtr pptInit );
static void RACPolySegment(DrawablePtr pDraw, GCPtr pGC, int nseg,
xSegment *pSeg );
static void RACPolyRectangle(DrawablePtr pDraw, GCPtr pGC, int nRectsInit,
xRectangle *pRectsInit );
static void RACPolyArc(DrawablePtr pDraw, GCPtr pGC, int narcs,
xArc *parcs );
static void RACFillPolygon(DrawablePtr pDraw, GCPtr pGC, int shape, int mode,
int count, DDXPointPtr ptsIn );
static void RACPolyFillRect( DrawablePtr pDraw, GCPtr pGC, int nrectFill,
xRectangle *prectInit );
static void RACPolyFillArc(DrawablePtr pDraw, GCPtr pGC, int narcs,
xArc *parcs );
static int RACPolyText8(DrawablePtr pDraw, GCPtr pGC, int x, int y,
int count, char *chars );
static int RACPolyText16(DrawablePtr pDraw, GCPtr pGC, int x, int y,
int count, unsigned short *chars );
static void RACImageText8(DrawablePtr pDraw, GCPtr pGC, int x, int y,
int count, char *chars );
static void RACImageText16(DrawablePtr pDraw, GCPtr pGC, int x, int y,
int count, unsigned short *chars );
static void RACImageGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int xInit,
int yInit, unsigned int nglyph,
CharInfoPtr *ppci, pointer pglyphBase );
static void RACPolyGlyphBlt(DrawablePtr pDraw, GCPtr pGC, int xInit,
int yInit, unsigned int nglyph,
CharInfoPtr *ppci, pointer pglyphBase );
static void RACPushPixels(GCPtr pGC, PixmapPtr pBitMap, DrawablePtr pDraw,
int dx, int dy, int xOrg, int yOrg );
/* miSpriteFuncs */
static Bool RACSpriteRealizeCursor(ScreenPtr pScreen, CursorPtr pCur);
static Bool RACSpriteUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCur);
static void RACSpriteSetCursor(ScreenPtr pScreen, CursorPtr pCur,
int x, int y);
static void RACSpriteMoveCursor(ScreenPtr pScreen, int x, int y);
#ifdef RENDER
static void RACComposite(CARD8 op, PicturePtr pSrc, PicturePtr pMask,
PicturePtr pDst, INT16 xSrc, INT16 ySrc,
INT16 xMask, INT16 yMask, INT16 xDst,
INT16 yDst, CARD16 width, CARD16 height);
static void RACGlyphs(CARD8 op, PicturePtr pSrc, PicturePtr pDst,
PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc,
int nlist, GlyphListPtr list, GlyphPtr *glyphs);
static void RACCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color,
int nRect, xRectangle *rects);
#endif
static GCFuncs RACGCFuncs = {
RACValidateGC, RACChangeGC, RACCopyGC, RACDestroyGC,
RACChangeClip, RACDestroyClip, RACCopyClip
};
static GCOps RACGCOps = {
RACFillSpans, RACSetSpans, RACPutImage, RACCopyArea,
RACCopyPlane, RACPolyPoint, RACPolylines, RACPolySegment,
RACPolyRectangle, RACPolyArc, RACFillPolygon, RACPolyFillRect,
RACPolyFillArc, RACPolyText8, RACPolyText16, RACImageText8,
RACImageText16, RACImageGlyphBlt, RACPolyGlyphBlt, RACPushPixels,
{NULL} /* devPrivate */
};
static miPointerSpriteFuncRec RACSpriteFuncs = {
RACSpriteRealizeCursor, RACSpriteUnrealizeCursor, RACSpriteSetCursor,
RACSpriteMoveCursor
};
static int RACScreenIndex = -1;
static int RACGCIndex = -1;
static unsigned long RACGeneration = 0;
Bool
xf86RACInit(ScreenPtr pScreen, unsigned int flag)
{
ScrnInfoPtr pScrn;
RACScreenPtr pScreenPriv;
miPointerScreenPtr PointPriv;
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
pScrn = xf86Screens[pScreen->myNum];
PointPriv = (miPointerScreenPtr)pScreen->devPrivates[miPointerScreenIndex].ptr;
DPRINT_S("RACInit",pScreen->myNum);
if (RACGeneration != serverGeneration) {
if ( ((RACScreenIndex = AllocateScreenPrivateIndex()) < 0) ||
((RACGCIndex = AllocateGCPrivateIndex()) < 0))
return FALSE;
RACGeneration = serverGeneration;
}
if (!AllocateGCPrivate(pScreen, RACGCIndex, sizeof(RACGCRec)))
return FALSE;
if (!(pScreenPriv = xalloc(sizeof(RACScreenRec))))
return FALSE;
pScreen->devPrivates[RACScreenIndex].ptr = (pointer)pScreenPriv;
WRAP_SCREEN(CloseScreen, RACCloseScreen);
WRAP_SCREEN(SaveScreen, RACSaveScreen);
WRAP_SCREEN_COND(CreateGC, RACCreateGC, RAC_FB);
WRAP_SCREEN_COND(GetImage, RACGetImage, RAC_FB);
WRAP_SCREEN_COND(GetSpans, RACGetSpans, RAC_FB);
WRAP_SCREEN_COND(SourceValidate, RACSourceValidate, RAC_FB);
WRAP_SCREEN_COND(PaintWindowBackground, RACPaintWindowBackground, RAC_FB);
WRAP_SCREEN_COND(PaintWindowBorder, RACPaintWindowBorder, RAC_FB);
WRAP_SCREEN_COND(CopyWindow, RACCopyWindow, RAC_FB);
WRAP_SCREEN_COND(ClearToBackground, RACClearToBackground, RAC_FB);
WRAP_SCREEN_COND(CreatePixmap, RACCreatePixmap, RAC_FB);
WRAP_SCREEN_COND(StoreColors, RACStoreColors, RAC_COLORMAP);
WRAP_SCREEN_COND(DisplayCursor, RACDisplayCursor, RAC_CURSOR);
WRAP_SCREEN_COND(RealizeCursor, RACRealizeCursor, RAC_CURSOR);
WRAP_SCREEN_COND(UnrealizeCursor, RACUnrealizeCursor, RAC_CURSOR);
WRAP_SCREEN_COND(RecolorCursor, RACRecolorCursor, RAC_CURSOR);
WRAP_SCREEN_COND(SetCursorPosition, RACSetCursorPosition, RAC_CURSOR);
#ifdef RENDER
WRAP_PICT_COND(Composite,RACComposite,RAC_FB);
WRAP_PICT_COND(Glyphs,RACGlyphs,RAC_FB);
WRAP_PICT_COND(CompositeRects,RACCompositeRects,RAC_FB);
#endif
WRAP_SCREEN_INFO_COND(AdjustFrame, RACAdjustFrame, RAC_VIEWPORT);
WRAP_SCREEN_INFO(SwitchMode, RACSwitchMode);
WRAP_SCREEN_INFO(EnterVT, RACEnterVT);
WRAP_SCREEN_INFO(LeaveVT, RACLeaveVT);
WRAP_SCREEN_INFO(FreeScreen, RACFreeScreen);
WRAP_SPRITE_COND(RAC_CURSOR);
return TRUE;
}
/* Screen funcs */
static Bool
RACCloseScreen (int i, ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
RACScreenPtr pScreenPriv =
(RACScreenPtr) pScreen->devPrivates[RACScreenIndex].ptr;
miPointerScreenPtr PointPriv
= (miPointerScreenPtr)pScreen->devPrivates[miPointerScreenIndex].ptr;
#ifdef RENDER
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
#endif
DPRINT_S("RACCloseScreen",pScreen->myNum);
UNWRAP_SCREEN(CreateGC);
UNWRAP_SCREEN(CloseScreen);
UNWRAP_SCREEN(GetImage);
UNWRAP_SCREEN(GetSpans);
UNWRAP_SCREEN(SourceValidate);
UNWRAP_SCREEN(PaintWindowBackground);
UNWRAP_SCREEN(PaintWindowBorder);
UNWRAP_SCREEN(CopyWindow);
UNWRAP_SCREEN(ClearToBackground);
UNWRAP_SCREEN(SaveScreen);
UNWRAP_SCREEN(StoreColors);
UNWRAP_SCREEN(DisplayCursor);
UNWRAP_SCREEN(RealizeCursor);
UNWRAP_SCREEN(UnrealizeCursor);
UNWRAP_SCREEN(RecolorCursor);
UNWRAP_SCREEN(SetCursorPosition);
#ifdef RENDER
UNWRAP_PICT(Composite);
UNWRAP_PICT(Glyphs);
UNWRAP_PICT(CompositeRects);
#endif
UNWRAP_SCREEN_INFO(AdjustFrame);
UNWRAP_SCREEN_INFO(SwitchMode);
UNWRAP_SCREEN_INFO(EnterVT);
UNWRAP_SCREEN_INFO(LeaveVT);
UNWRAP_SCREEN_INFO(FreeScreen);
UNWRAP_SPRITE;
xfree ((pointer) pScreenPriv);
if (xf86Screens[pScreen->myNum]->vtSema) {
xf86EnterServerState(SETUP);
ENABLE;
}
return (*pScreen->CloseScreen) (i, pScreen);
}
static void
RACGetImage (
DrawablePtr pDrawable,
int sx, int sy, int w, int h,
unsigned int format,
unsigned long planemask,
char *pdstLine
)
{
ScreenPtr pScreen = pDrawable->pScreen;
DPRINT_S("RACGetImage",pScreen->myNum);
SCREEN_PROLOG(GetImage);
if (xf86Screens[pScreen->myNum]->vtSema) {
ENABLE;
}
(*pScreen->GetImage) (pDrawable, sx, sy, w, h,
format, planemask, pdstLine);
SCREEN_EPILOG (GetImage, RACGetImage);
}
static void
RACGetSpans (
DrawablePtr pDrawable,
int wMax,
DDXPointPtr ppt,
int *pwidth,
int nspans,
char *pdstStart
)
{
ScreenPtr pScreen = pDrawable->pScreen;
DPRINT_S("RACGetSpans",pScreen->myNum);
SCREEN_PROLOG (GetSpans);
ENABLE;
(*pScreen->GetSpans) (pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
SCREEN_EPILOG (GetSpans, RACGetSpans);
}
static void
RACSourceValidate (
DrawablePtr pDrawable,
int x, int y, int width, int height )
{
ScreenPtr pScreen = pDrawable->pScreen;
DPRINT_S("RACSourceValidate",pScreen->myNum);
SCREEN_PROLOG (SourceValidate);
ENABLE;
if (pScreen->SourceValidate)
(*pScreen->SourceValidate) (pDrawable, x, y, width, height);
SCREEN_EPILOG (SourceValidate, RACSourceValidate);
}
static void
RACPaintWindowBackground(
WindowPtr pWin,
RegionPtr prgn,
int what
)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DPRINT_S("RACPaintWindowBackground",pScreen->myNum);
SCREEN_PROLOG (PaintWindowBackground);
ENABLE;
(*pScreen->PaintWindowBackground) (pWin, prgn, what);
SCREEN_EPILOG (PaintWindowBackground, RACPaintWindowBackground);
}
static void
RACPaintWindowBorder(
WindowPtr pWin,
RegionPtr prgn,
int what
)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DPRINT_S("RACPaintWindowBorder",pScreen->myNum);
SCREEN_PROLOG (PaintWindowBorder);
ENABLE;
(*pScreen->PaintWindowBorder) (pWin, prgn, what);
SCREEN_EPILOG (PaintWindowBorder, RACPaintWindowBorder);
}
static void
RACCopyWindow(
WindowPtr pWin,
DDXPointRec ptOldOrg,
RegionPtr prgnSrc )
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DPRINT_S("RACCopyWindow",pScreen->myNum);
SCREEN_PROLOG (CopyWindow);
ENABLE;
(*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
SCREEN_EPILOG (CopyWindow, RACCopyWindow);
}
static void
RACClearToBackground (
WindowPtr pWin,
int x, int y,
int w, int h,
Bool generateExposures )
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DPRINT_S("RACClearToBackground",pScreen->myNum);
SCREEN_PROLOG ( ClearToBackground);
ENABLE;
(*pScreen->ClearToBackground) (pWin, x, y, w, h, generateExposures);
SCREEN_EPILOG (ClearToBackground, RACClearToBackground);
}
static PixmapPtr
RACCreatePixmap(ScreenPtr pScreen, int w, int h, int depth)
{
PixmapPtr pPix;
DPRINT_S("RACCreatePixmap",pScreen->myNum);
SCREEN_PROLOG ( CreatePixmap);
ENABLE;
pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth);
SCREEN_EPILOG (CreatePixmap, RACCreatePixmap);
return pPix;
}
static Bool
RACSaveScreen(ScreenPtr pScreen, Bool unblank)
{
Bool val;
DPRINT_S("RACSaveScreen",pScreen->myNum);
SCREEN_PROLOG (SaveScreen);
ENABLE;
val = (*pScreen->SaveScreen) (pScreen, unblank);
SCREEN_EPILOG (SaveScreen, RACSaveScreen);
return val;
}
static void
RACStoreColors (
ColormapPtr pmap,
int ndef,
xColorItem *pdefs)
{
ScreenPtr pScreen = pmap->pScreen;
DPRINT_S("RACStoreColors",pScreen->myNum);
SCREEN_PROLOG (StoreColors);
ENABLE;
(*pScreen->StoreColors) (pmap,ndef,pdefs);
SCREEN_EPILOG ( StoreColors, RACStoreColors);
}
static void
RACRecolorCursor (
ScreenPtr pScreen,
CursorPtr pCurs,
Bool displayed
)
{
DPRINT_S("RACRecolorCursor",pScreen->myNum);
SCREEN_PROLOG (RecolorCursor);
ENABLE;
(*pScreen->RecolorCursor) (pScreen,pCurs,displayed);
SCREEN_EPILOG ( RecolorCursor, RACRecolorCursor);
}
static Bool
RACRealizeCursor (
ScreenPtr pScreen,
CursorPtr pCursor
)
{
Bool val;
DPRINT_S("RACRealizeCursor",pScreen->myNum);
SCREEN_PROLOG (RealizeCursor);
ENABLE;
val = (*pScreen->RealizeCursor) (pScreen,pCursor);
SCREEN_EPILOG ( RealizeCursor, RACRealizeCursor);
return val;
}
static Bool
RACUnrealizeCursor (
ScreenPtr pScreen,
CursorPtr pCursor
)
{
Bool val;
DPRINT_S("RACUnrealizeCursor",pScreen->myNum);
SCREEN_PROLOG (UnrealizeCursor);
ENABLE;
val = (*pScreen->UnrealizeCursor) (pScreen,pCursor);
SCREEN_EPILOG ( UnrealizeCursor, RACUnrealizeCursor);
return val;
}
static Bool
RACDisplayCursor (
ScreenPtr pScreen,
CursorPtr pCursor
)
{
Bool val;
DPRINT_S("RACDisplayCursor",pScreen->myNum);
SCREEN_PROLOG (DisplayCursor);
ENABLE;
val = (*pScreen->DisplayCursor) (pScreen,pCursor);
SCREEN_EPILOG ( DisplayCursor, RACDisplayCursor);
return val;
}
static Bool
RACSetCursorPosition (
ScreenPtr pScreen,
int x, int y,
Bool generateEvent)
{
Bool val;
DPRINT_S("RACSetCursorPosition",pScreen->myNum);
SCREEN_PROLOG (SetCursorPosition);
ENABLE;
val = (*pScreen->SetCursorPosition) (pScreen,x,y,generateEvent);
SCREEN_EPILOG ( SetCursorPosition, RACSetCursorPosition);
return val;
}
static void
RACAdjustFrame(int index, int x, int y, int flags)
{
ScreenPtr pScreen = screenInfo.screens[index];
RACScreenPtr pScreenPriv =
(RACScreenPtr) pScreen->devPrivates[RACScreenIndex].ptr;
DPRINT_S("RACAdjustFrame",index);
xf86EnableAccess(xf86Screens[index]);
(*pScreenPriv->AdjustFrame)(index, x, y, flags);
}
static Bool
RACSwitchMode(int index, DisplayModePtr mode, int flags)
{
ScreenPtr pScreen = screenInfo.screens[index];
RACScreenPtr pScreenPriv =
(RACScreenPtr) pScreen->devPrivates[RACScreenIndex].ptr;
DPRINT_S("RACSwitchMode",index);
xf86EnableAccess(xf86Screens[index]);
return (*pScreenPriv->SwitchMode)(index, mode, flags);
}
static Bool
RACEnterVT(int index, int flags)
{
ScreenPtr pScreen = screenInfo.screens[index];
RACScreenPtr pScreenPriv =
(RACScreenPtr) pScreen->devPrivates[RACScreenIndex].ptr;
DPRINT_S("RACEnterVT",index);
xf86EnableAccess(xf86Screens[index]);
return (*pScreenPriv->EnterVT)(index, flags);
}
static void
RACLeaveVT(int index, int flags)
{
ScreenPtr pScreen = screenInfo.screens[index];
RACScreenPtr pScreenPriv =
(RACScreenPtr) pScreen->devPrivates[RACScreenIndex].ptr;
DPRINT_S("RACLeaveVT",index);
xf86EnableAccess(xf86Screens[index]);
(*pScreenPriv->LeaveVT)(index, flags);
}
static void
RACFreeScreen(int index, int flags)
{
ScreenPtr pScreen = screenInfo.screens[index];
RACScreenPtr pScreenPriv =
(RACScreenPtr) pScreen->devPrivates[RACScreenIndex].ptr;
DPRINT_S("RACFreeScreen",index);
xf86EnableAccess(xf86Screens[index]);
(*pScreenPriv->FreeScreen)(index, flags);
}
static Bool
RACCreateGC(GCPtr pGC)
{
ScreenPtr pScreen = pGC->pScreen;
RACGCPtr pGCPriv = (RACGCPtr) (pGC)->devPrivates[RACGCIndex].ptr;
Bool ret;
DPRINT_S("RACCreateGC",pScreen->myNum);
SCREEN_PROLOG(CreateGC);
ret = (*pScreen->CreateGC)(pGC);
GC_WRAP(pGC);
SCREEN_EPILOG(CreateGC,RACCreateGC);
return ret;
}
/* GC funcs */
static void
RACValidateGC(
GCPtr pGC,
unsigned long changes,
DrawablePtr pDraw )
{
GC_UNWRAP(pGC);
DPRINT("RACValidateGC");
(*pGC->funcs->ValidateGC)(pGC, changes, pDraw);
GC_WRAP(pGC);
}
static void
RACDestroyGC(GCPtr pGC)
{
GC_UNWRAP (pGC);
DPRINT("RACDestroyGC");
(*pGC->funcs->DestroyGC)(pGC);
GC_WRAP (pGC);
}
static void
RACChangeGC (
GCPtr pGC,
unsigned long mask)
{
GC_UNWRAP (pGC);
DPRINT("RACChangeGC");
(*pGC->funcs->ChangeGC) (pGC, mask);
GC_WRAP (pGC);
}
static void
RACCopyGC (
GCPtr pGCSrc,
unsigned long mask,
GCPtr pGCDst)
{
GC_UNWRAP (pGCDst);
DPRINT("RACCopyGC");
(*pGCDst->funcs->CopyGC) (pGCSrc, mask, pGCDst);
GC_WRAP (pGCDst);
}
static void
RACChangeClip (
GCPtr pGC,
int type,
pointer pvalue,
int nrects )
{
GC_UNWRAP (pGC);
DPRINT("RACChangeClip");
(*pGC->funcs->ChangeClip) (pGC, type, pvalue, nrects);
GC_WRAP (pGC);
}
static void
RACCopyClip(GCPtr pgcDst, GCPtr pgcSrc)
{
GC_UNWRAP (pgcDst);
DPRINT("RACCopyClip");
(* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
GC_WRAP (pgcDst);
}
static void
RACDestroyClip(GCPtr pGC)
{
GC_UNWRAP (pGC);
DPRINT("RACDestroyClip");
(* pGC->funcs->DestroyClip)(pGC);
GC_WRAP (pGC);
}
/* GC Ops */
static void
RACFillSpans(
DrawablePtr pDraw,
GC *pGC,
int nInit,
DDXPointPtr pptInit,
int *pwidthInit,
int fSorted )
{
GC_UNWRAP(pGC);
DPRINT("RACFillSpans");
ENABLE_GC;
(*pGC->ops->FillSpans)(pDraw, pGC, nInit, pptInit, pwidthInit, fSorted);
GC_WRAP(pGC);
}
static void
RACSetSpans(
DrawablePtr pDraw,
GCPtr pGC,
char *pcharsrc,
register DDXPointPtr ppt,
int *pwidth,
int nspans,
int fSorted )
{
GC_UNWRAP(pGC);
DPRINT("RACSetSpans");
ENABLE_GC;
(*pGC->ops->SetSpans)(pDraw, pGC, pcharsrc, ppt, pwidth, nspans, fSorted);
GC_WRAP(pGC);
}
static void
RACPutImage(
DrawablePtr pDraw,
GCPtr pGC,
int depth,
int x, int y, int w, int h,
int leftPad,
int format,
char *pImage )
{
GC_UNWRAP(pGC);
DPRINT("RACPutImage");
ENABLE_GC;
(*pGC->ops->PutImage)(pDraw, pGC, depth, x, y, w, h,
leftPad, format, pImage);
GC_WRAP(pGC);
}
static RegionPtr
RACCopyArea(
DrawablePtr pSrc,
DrawablePtr pDst,
GC *pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty )
{
RegionPtr ret;
GC_UNWRAP(pGC);
DPRINT("RACCopyArea");
ENABLE_GC;
ret = (*pGC->ops->CopyArea)(pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty);
GC_WRAP(pGC);
return ret;
}
static RegionPtr
RACCopyPlane(
DrawablePtr pSrc,
DrawablePtr pDst,
GCPtr pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty,
unsigned long bitPlane )
{
RegionPtr ret;
GC_UNWRAP(pGC);
DPRINT("RACCopyPlane");
ENABLE_GC;
ret = (*pGC->ops->CopyPlane)(pSrc, pDst, pGC, srcx, srcy,
width, height, dstx, dsty, bitPlane);
GC_WRAP(pGC);
return ret;
}
static void
RACPolyPoint(
DrawablePtr pDraw,
GCPtr pGC,
int mode,
int npt,
xPoint *pptInit )
{
GC_UNWRAP(pGC);
DPRINT("RACPolyPoint");
ENABLE_GC;
(*pGC->ops->PolyPoint)(pDraw, pGC, mode, npt, pptInit);
GC_WRAP(pGC);
}
static void
RACPolylines(
DrawablePtr pDraw,
GCPtr pGC,
int mode,
int npt,
DDXPointPtr pptInit )
{
GC_UNWRAP(pGC);
DPRINT("RACPolylines");
ENABLE_GC;
(*pGC->ops->Polylines)(pDraw, pGC, mode, npt, pptInit);
GC_WRAP(pGC);
}
static void
RACPolySegment(
DrawablePtr pDraw,
GCPtr pGC,
int nseg,
xSegment *pSeg )
{
GC_UNWRAP(pGC);
DPRINT("RACPolySegment");
ENABLE_GC;
(*pGC->ops->PolySegment)(pDraw, pGC, nseg, pSeg);
GC_WRAP(pGC);
}
static void
RACPolyRectangle(
DrawablePtr pDraw,
GCPtr pGC,
int nRectsInit,
xRectangle *pRectsInit )
{
GC_UNWRAP(pGC);
DPRINT("RACPolyRectangle");
ENABLE_GC;
(*pGC->ops->PolyRectangle)(pDraw, pGC, nRectsInit, pRectsInit);
GC_WRAP(pGC);
}
static void
RACPolyArc(
DrawablePtr pDraw,
GCPtr pGC,
int narcs,
xArc *parcs )
{
GC_UNWRAP(pGC);
DPRINT("RACPolyArc");
ENABLE_GC;
(*pGC->ops->PolyArc)(pDraw, pGC, narcs, parcs);
GC_WRAP(pGC);
}
static void
RACFillPolygon(
DrawablePtr pDraw,
GCPtr pGC,
int shape,
int mode,
int count,
DDXPointPtr ptsIn )
{
GC_UNWRAP(pGC);
DPRINT("RACFillPolygon");
ENABLE_GC;
(*pGC->ops->FillPolygon)(pDraw, pGC, shape, mode, count, ptsIn);
GC_WRAP(pGC);
}
static void
RACPolyFillRect(
DrawablePtr pDraw,
GCPtr pGC,
int nrectFill,
xRectangle *prectInit )
{
GC_UNWRAP(pGC);
DPRINT("RACPolyFillRect");
ENABLE_GC;
(*pGC->ops->PolyFillRect)(pDraw, pGC, nrectFill, prectInit);
GC_WRAP(pGC);
}
static void
RACPolyFillArc(
DrawablePtr pDraw,
GCPtr pGC,
int narcs,
xArc *parcs )
{
GC_UNWRAP(pGC);
DPRINT("RACPolyFillArc");
ENABLE_GC;
(*pGC->ops->PolyFillArc)(pDraw, pGC, narcs, parcs);
GC_WRAP(pGC);
}
static int
RACPolyText8(
DrawablePtr pDraw,
GCPtr pGC,
int x,
int y,
int count,
char *chars )
{
int ret;
GC_UNWRAP(pGC);
DPRINT("RACPolyText8");
ENABLE_GC;
ret = (*pGC->ops->PolyText8)(pDraw, pGC, x, y, count, chars);
GC_WRAP(pGC);
return ret;
}
static int
RACPolyText16(
DrawablePtr pDraw,
GCPtr pGC,
int x,
int y,
int count,
unsigned short *chars )
{
int ret;
GC_UNWRAP(pGC);
DPRINT("RACPolyText16");
ENABLE_GC;
ret = (*pGC->ops->PolyText16)(pDraw, pGC, x, y, count, chars);
GC_WRAP(pGC);
return ret;
}
static void
RACImageText8(
DrawablePtr pDraw,
GCPtr pGC,
int x,
int y,
int count,
char *chars )
{
GC_UNWRAP(pGC);
DPRINT("RACImageText8");
ENABLE_GC;
(*pGC->ops->ImageText8)(pDraw, pGC, x, y, count, chars);
GC_WRAP(pGC);
}
static void
RACImageText16(
DrawablePtr pDraw,
GCPtr pGC,
int x,
int y,
int count,
unsigned short *chars )
{
GC_UNWRAP(pGC);
DPRINT("RACImageText16");
ENABLE_GC;
(*pGC->ops->ImageText16)(pDraw, pGC, x, y, count, chars);
GC_WRAP(pGC);
}
static void
RACImageGlyphBlt(
DrawablePtr pDraw,
GCPtr pGC,
int xInit, int yInit,
unsigned int nglyph,
CharInfoPtr *ppci,
pointer pglyphBase )
{
GC_UNWRAP(pGC);
DPRINT("RACImageGlyphBlt");
ENABLE_GC;
(*pGC->ops->ImageGlyphBlt)(pDraw, pGC, xInit, yInit,
nglyph, ppci, pglyphBase);
GC_WRAP(pGC);
}
static void
RACPolyGlyphBlt(
DrawablePtr pDraw,
GCPtr pGC,
int xInit, int yInit,
unsigned int nglyph,
CharInfoPtr *ppci,
pointer pglyphBase )
{
GC_UNWRAP(pGC);
DPRINT("RACPolyGlyphBlt");
ENABLE_GC;
(*pGC->ops->PolyGlyphBlt)(pDraw, pGC, xInit, yInit,
nglyph, ppci, pglyphBase);
GC_WRAP(pGC);
}
static void
RACPushPixels(
GCPtr pGC,
PixmapPtr pBitMap,
DrawablePtr pDraw,
int dx, int dy, int xOrg, int yOrg )
{
GC_UNWRAP(pGC);
DPRINT("RACPushPixels");
ENABLE_GC;
(*pGC->ops->PushPixels)(pGC, pBitMap, pDraw, dx, dy, xOrg, yOrg);
GC_WRAP(pGC);
}
/* miSpriteFuncs */
static Bool
RACSpriteRealizeCursor(ScreenPtr pScreen, CursorPtr pCur)
{
Bool val;
SPRITE_PROLOG;
DPRINT_S("RACSpriteRealizeCursor",pScreen->myNum);
ENABLE;
val = PointPriv->spriteFuncs->RealizeCursor(pScreen, pCur);
SPRITE_EPILOG;
return val;
}
static Bool
RACSpriteUnrealizeCursor(ScreenPtr pScreen, CursorPtr pCur)
{
Bool val;
SPRITE_PROLOG;
DPRINT_S("RACSpriteUnrealizeCursor",pScreen->myNum);
ENABLE;
val = PointPriv->spriteFuncs->UnrealizeCursor(pScreen, pCur);
SPRITE_EPILOG;
return val;
}
static void
RACSpriteSetCursor(ScreenPtr pScreen, CursorPtr pCur, int x, int y)
{
SPRITE_PROLOG;
DPRINT_S("RACSpriteSetCursor",pScreen->myNum);
ENABLE;
PointPriv->spriteFuncs->SetCursor(pScreen, pCur, x, y);
SPRITE_EPILOG;
}
static void
RACSpriteMoveCursor(ScreenPtr pScreen, int x, int y)
{
SPRITE_PROLOG;
DPRINT_S("RACSpriteMoveCursor",pScreen->myNum);
ENABLE;
PointPriv->spriteFuncs->MoveCursor(pScreen, x, y);
SPRITE_EPILOG;
}
#ifdef RENDER
static void
RACComposite(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);
ENABLE;
(*ps->Composite) (op, pSrc, pMask, pDst, xSrc, ySrc, xMask, yMask, xDst,
yDst, width, height);
PICTURE_EPILOGUE(Composite, RACComposite);
}
static void
RACGlyphs(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);
ENABLE;
(*ps->Glyphs)(op, pSrc, pDst, maskFormat, xSrc, ySrc, nlist, list, glyphs);
PICTURE_EPILOGUE (Glyphs, RACGlyphs);
}
static void
RACCompositeRects(CARD8 op, PicturePtr pDst, xRenderColor *color, int nRect,
xRectangle *rects)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
PictureScreenPtr ps = GetPictureScreen(pScreen);
PICTURE_PROLOGUE(CompositeRects);
ENABLE;
(*ps->CompositeRects)(op, pDst, color, nRect, rects);
PICTURE_EPILOGUE (CompositeRects, RACCompositeRects);
}
#endif
Reference in New Issue View Git Blame Copy Permalink