2005-07-03 09:02:09 +02:00
|
|
|
#ifdef HAVE_XORG_CONFIG_H
|
|
|
|
#include <xorg-config.h>
|
|
|
|
#endif
|
|
|
|
|
2005-07-03 10:53:54 +02:00
|
|
|
#include "misc.h"
|
2003-11-14 17:48:57 +01:00
|
|
|
#include "xf86.h"
|
|
|
|
#include "xf86_OSproc.h"
|
|
|
|
|
2005-04-20 14:25:48 +02:00
|
|
|
#include <X11/X.h>
|
2003-11-14 17:48:57 +01:00
|
|
|
#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
|
|
|
|
|
2007-08-28 15:28:25 +02:00
|
|
|
#define SCREEN_PROLOG(x) pScreen->x = ((RACScreenPtr) \
|
|
|
|
dixLookupPrivate(&(pScreen)->devPrivates, RACScreenKey))->x
|
2003-11-14 17:48:57 +01:00
|
|
|
#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;}
|
|
|
|
|
2007-08-28 15:28:25 +02:00
|
|
|
#define PICTURE_PROLOGUE(field) ps->field = \
|
|
|
|
((RACScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, RACScreenKey))->field
|
2003-11-14 17:48:57 +01:00
|
|
|
#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 = \
|
2007-08-28 15:28:25 +02:00
|
|
|
(miPointerScreenPtr)dixLookupPrivate(&pScreen->devPrivates, miPointerScreenKey); \
|
|
|
|
RACScreenPtr pScreenPriv = \
|
|
|
|
((RACScreenPtr)dixLookupPrivate(&(pScreen)->devPrivates, RACScreenKey));\
|
2003-11-14 17:48:57 +01:00
|
|
|
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)\
|
2007-08-28 15:28:25 +02:00
|
|
|
RACGCPtr pGCPriv = (RACGCPtr)dixLookupPrivate(&(x)->devPrivates, RACGCKey);\
|
2003-11-14 17:48:57 +01:00
|
|
|
(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;
|
|
|
|
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 RACCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg,
|
|
|
|
RegionPtr prgnSrc );
|
|
|
|
static void RACClearToBackground (WindowPtr pWin, int x, int y,
|
|
|
|
int w, int h, Bool generateExposures );
|
2007-10-31 22:15:35 +01:00
|
|
|
static PixmapPtr RACCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
|
|
|
|
unsigned usage_hint);
|
2003-11-14 17:48:57 +01:00
|
|
|
static Bool RACCreateGC(GCPtr pGC);
|
|
|
|
static Bool RACSaveScreen(ScreenPtr pScreen, Bool unblank);
|
|
|
|
static void RACStoreColors (ColormapPtr pmap, int ndef, xColorItem *pdefs);
|
2006-11-23 07:45:14 +01:00
|
|
|
static void RACRecolorCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCurs, Bool displayed);
|
|
|
|
static Bool RACRealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCursor);
|
|
|
|
static Bool RACUnrealizeCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCursor);
|
|
|
|
static Bool RACDisplayCursor (DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCursor);
|
|
|
|
static Bool RACSetCursorPosition (DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
int x, int y, Bool generateEvent);
|
2003-11-14 17:48:57 +01:00
|
|
|
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 */
|
2006-11-17 05:40:37 +01:00
|
|
|
static Bool RACSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCur);
|
|
|
|
static Bool RACSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCur);
|
|
|
|
static void RACSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCur, int x, int y);
|
|
|
|
static void RACSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
int x, int y);
|
2003-11-14 17:48:57 +01:00
|
|
|
#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
|
|
|
|
|
2006-06-19 05:54:04 +02:00
|
|
|
static GCFuncs RACGCFuncs = {
|
2003-11-14 17:48:57 +01:00
|
|
|
RACValidateGC, RACChangeGC, RACCopyGC, RACDestroyGC,
|
|
|
|
RACChangeClip, RACDestroyClip, RACCopyClip
|
|
|
|
};
|
|
|
|
|
2006-06-19 05:54:04 +02:00
|
|
|
static GCOps RACGCOps = {
|
2003-11-14 17:48:57 +01:00
|
|
|
RACFillSpans, RACSetSpans, RACPutImage, RACCopyArea,
|
|
|
|
RACCopyPlane, RACPolyPoint, RACPolylines, RACPolySegment,
|
|
|
|
RACPolyRectangle, RACPolyArc, RACFillPolygon, RACPolyFillRect,
|
|
|
|
RACPolyFillArc, RACPolyText8, RACPolyText16, RACImageText8,
|
|
|
|
RACImageText16, RACImageGlyphBlt, RACPolyGlyphBlt, RACPushPixels,
|
|
|
|
{NULL} /* devPrivate */
|
|
|
|
};
|
|
|
|
|
2006-06-19 05:54:04 +02:00
|
|
|
static miPointerSpriteFuncRec RACSpriteFuncs = {
|
2003-11-14 17:48:57 +01:00
|
|
|
RACSpriteRealizeCursor, RACSpriteUnrealizeCursor, RACSpriteSetCursor,
|
|
|
|
RACSpriteMoveCursor
|
|
|
|
};
|
|
|
|
|
2008-08-29 00:05:40 +02:00
|
|
|
static int RACScreenKeyIndex;
|
|
|
|
static DevPrivateKey RACScreenKey = &RACScreenKeyIndex;
|
|
|
|
static int RACGCKeyIndex;
|
|
|
|
static DevPrivateKey RACGCKey = &RACGCKeyIndex;
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
|
Rework symbol visibility for easier maintenance
Save in a few special cases, _X_EXPORT should not be used in C source
files. Instead, it should be used in headers, and the proper C source
include that header. Some special cases are symbols that need to be
shared between modules, but not expected to be used by external drivers,
and symbols that are accessible via LoaderSymbol/dlopen.
This patch also adds conditionally some new sdk header files, depending
on extensions enabled. These files were added to match pattern for
other extensions/modules, that is, have the headers "deciding" symbol
visibility in the sdk. These headers are:
o Xext/panoramiXsrv.h, Xext/panoramiX.h
o fbpict.h (unconditionally)
o vidmodeproc.h
o mioverlay.h (unconditionally, used only by xaa)
o xfixes.h (unconditionally, symbols required by dri2)
LoaderSymbol and similar functions now don't have different prototypes,
in loaderProcs.h and xf86Module.h, so that both headers can be included,
without the need of defining IN_LOADER.
xf86NewInputDevice() device prototype readded to xf86Xinput.h, but
not exported (and with a comment about it).
2008-12-03 08:43:34 +01:00
|
|
|
Bool
|
2003-11-14 17:48:57 +01:00
|
|
|
xf86RACInit(ScreenPtr pScreen, unsigned int flag)
|
|
|
|
{
|
|
|
|
ScrnInfoPtr pScrn;
|
|
|
|
RACScreenPtr pScreenPriv;
|
|
|
|
miPointerScreenPtr PointPriv;
|
|
|
|
#ifdef RENDER
|
|
|
|
PictureScreenPtr ps = GetPictureScreenIfSet(pScreen);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
pScrn = xf86Screens[pScreen->myNum];
|
2007-08-28 15:28:25 +02:00
|
|
|
PointPriv = (miPointerScreenPtr)dixLookupPrivate(&pScreen->devPrivates,
|
|
|
|
miPointerScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
DPRINT_S("RACInit",pScreen->myNum);
|
|
|
|
|
2007-08-28 15:28:25 +02:00
|
|
|
if (!dixRequestPrivate(RACGCKey, sizeof(RACGCRec)))
|
2003-11-14 17:48:57 +01:00
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (!(pScreenPriv = xalloc(sizeof(RACScreenRec))))
|
|
|
|
return FALSE;
|
|
|
|
|
2007-08-28 15:28:25 +02:00
|
|
|
dixSetPrivate(&pScreen->devPrivates, RACScreenKey, pScreenPriv);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
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(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];
|
2007-08-28 15:28:25 +02:00
|
|
|
RACScreenPtr pScreenPriv = (RACScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, RACScreenKey);
|
|
|
|
miPointerScreenPtr PointPriv = (miPointerScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, miPointerScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
#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(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
|
|
|
|
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
|
2007-10-31 22:15:35 +01:00
|
|
|
RACCreatePixmap(ScreenPtr pScreen, int w, int h, int depth, unsigned usage_hint)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
PixmapPtr pPix;
|
|
|
|
|
|
|
|
DPRINT_S("RACCreatePixmap",pScreen->myNum);
|
|
|
|
SCREEN_PROLOG ( CreatePixmap);
|
|
|
|
ENABLE;
|
2007-10-31 22:15:35 +01:00
|
|
|
pPix = (*pScreen->CreatePixmap) (pScreen, w, h, depth, usage_hint);
|
2003-11-14 17:48:57 +01:00
|
|
|
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 (
|
2006-11-23 07:45:14 +01:00
|
|
|
DeviceIntPtr pDev,
|
2003-11-14 17:48:57 +01:00
|
|
|
ScreenPtr pScreen,
|
|
|
|
CursorPtr pCurs,
|
|
|
|
Bool displayed
|
|
|
|
)
|
|
|
|
{
|
|
|
|
DPRINT_S("RACRecolorCursor",pScreen->myNum);
|
|
|
|
SCREEN_PROLOG (RecolorCursor);
|
|
|
|
ENABLE;
|
2006-11-23 07:45:14 +01:00
|
|
|
(*pScreen->RecolorCursor) (pDev, pScreen,pCurs,displayed);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
SCREEN_EPILOG ( RecolorCursor, RACRecolorCursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
RACRealizeCursor (
|
2006-11-23 07:45:14 +01:00
|
|
|
DeviceIntPtr pDev,
|
|
|
|
ScreenPtr pScreen,
|
|
|
|
CursorPtr pCursor
|
2003-11-14 17:48:57 +01:00
|
|
|
)
|
|
|
|
{
|
|
|
|
Bool val;
|
|
|
|
|
|
|
|
DPRINT_S("RACRealizeCursor",pScreen->myNum);
|
|
|
|
SCREEN_PROLOG (RealizeCursor);
|
|
|
|
ENABLE;
|
2006-11-23 07:45:14 +01:00
|
|
|
val = (*pScreen->RealizeCursor) (pDev, pScreen,pCursor);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
SCREEN_EPILOG ( RealizeCursor, RACRealizeCursor);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
RACUnrealizeCursor (
|
2006-11-23 07:45:14 +01:00
|
|
|
DeviceIntPtr pDev,
|
|
|
|
ScreenPtr pScreen,
|
|
|
|
CursorPtr pCursor
|
2003-11-14 17:48:57 +01:00
|
|
|
)
|
|
|
|
{
|
|
|
|
Bool val;
|
|
|
|
|
|
|
|
DPRINT_S("RACUnrealizeCursor",pScreen->myNum);
|
|
|
|
SCREEN_PROLOG (UnrealizeCursor);
|
|
|
|
ENABLE;
|
2006-11-23 07:45:14 +01:00
|
|
|
val = (*pScreen->UnrealizeCursor) (pDev, pScreen,pCursor);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
SCREEN_EPILOG ( UnrealizeCursor, RACUnrealizeCursor);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
RACDisplayCursor (
|
2006-11-23 07:45:14 +01:00
|
|
|
DeviceIntPtr pDev,
|
|
|
|
ScreenPtr pScreen,
|
|
|
|
CursorPtr pCursor
|
2003-11-14 17:48:57 +01:00
|
|
|
)
|
|
|
|
{
|
|
|
|
Bool val;
|
|
|
|
|
|
|
|
DPRINT_S("RACDisplayCursor",pScreen->myNum);
|
|
|
|
SCREEN_PROLOG (DisplayCursor);
|
|
|
|
ENABLE;
|
2006-11-23 07:45:14 +01:00
|
|
|
val = (*pScreen->DisplayCursor) (pDev, pScreen,pCursor);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
SCREEN_EPILOG ( DisplayCursor, RACDisplayCursor);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
RACSetCursorPosition (
|
2006-11-23 07:45:14 +01:00
|
|
|
DeviceIntPtr pDev,
|
2003-11-14 17:48:57 +01:00
|
|
|
ScreenPtr pScreen,
|
|
|
|
int x, int y,
|
|
|
|
Bool generateEvent)
|
|
|
|
{
|
|
|
|
Bool val;
|
|
|
|
|
|
|
|
DPRINT_S("RACSetCursorPosition",pScreen->myNum);
|
|
|
|
SCREEN_PROLOG (SetCursorPosition);
|
|
|
|
ENABLE;
|
2006-11-23 07:45:14 +01:00
|
|
|
val = (*pScreen->SetCursorPosition) (pDev, pScreen,x,y,generateEvent);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
SCREEN_EPILOG ( SetCursorPosition, RACSetCursorPosition);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
RACAdjustFrame(int index, int x, int y, int flags)
|
|
|
|
{
|
|
|
|
ScreenPtr pScreen = screenInfo.screens[index];
|
2007-08-28 15:28:25 +02:00
|
|
|
RACScreenPtr pScreenPriv = (RACScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, RACScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
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];
|
2007-08-28 15:28:25 +02:00
|
|
|
RACScreenPtr pScreenPriv = (RACScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, RACScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
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];
|
2007-08-28 15:28:25 +02:00
|
|
|
RACScreenPtr pScreenPriv = (RACScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, RACScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
DPRINT_S("RACEnterVT",index);
|
|
|
|
xf86EnableAccess(xf86Screens[index]);
|
|
|
|
|
|
|
|
return (*pScreenPriv->EnterVT)(index, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
RACLeaveVT(int index, int flags)
|
|
|
|
{
|
|
|
|
ScreenPtr pScreen = screenInfo.screens[index];
|
2007-08-28 15:28:25 +02:00
|
|
|
RACScreenPtr pScreenPriv = (RACScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, RACScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
DPRINT_S("RACLeaveVT",index);
|
|
|
|
xf86EnableAccess(xf86Screens[index]);
|
|
|
|
|
|
|
|
(*pScreenPriv->LeaveVT)(index, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
RACFreeScreen(int index, int flags)
|
|
|
|
{
|
|
|
|
ScreenPtr pScreen = screenInfo.screens[index];
|
2007-08-28 15:28:25 +02:00
|
|
|
RACScreenPtr pScreenPriv = (RACScreenPtr)dixLookupPrivate(
|
|
|
|
&pScreen->devPrivates, RACScreenKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
|
|
|
|
DPRINT_S("RACFreeScreen",index);
|
|
|
|
xf86EnableAccess(xf86Screens[index]);
|
|
|
|
|
|
|
|
(*pScreenPriv->FreeScreen)(index, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
|
|
|
RACCreateGC(GCPtr pGC)
|
|
|
|
{
|
|
|
|
ScreenPtr pScreen = pGC->pScreen;
|
2007-08-28 15:28:25 +02:00
|
|
|
RACGCPtr pGCPriv = (RACGCPtr)dixLookupPrivate(&pGC->devPrivates, RACGCKey);
|
2003-11-14 17:48:57 +01:00
|
|
|
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
|
2006-11-17 05:40:37 +01:00
|
|
|
RACSpriteRealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
Bool val;
|
|
|
|
SPRITE_PROLOG;
|
|
|
|
DPRINT_S("RACSpriteRealizeCursor",pScreen->myNum);
|
|
|
|
ENABLE;
|
2006-11-17 05:40:37 +01:00
|
|
|
val = PointPriv->spriteFuncs->RealizeCursor(pDev, pScreen, pCur);
|
2003-11-14 17:48:57 +01:00
|
|
|
SPRITE_EPILOG;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Bool
|
2006-11-17 05:40:37 +01:00
|
|
|
RACSpriteUnrealizeCursor(DeviceIntPtr pDev, ScreenPtr pScreen, CursorPtr pCur)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
Bool val;
|
|
|
|
SPRITE_PROLOG;
|
|
|
|
DPRINT_S("RACSpriteUnrealizeCursor",pScreen->myNum);
|
|
|
|
ENABLE;
|
2006-11-17 05:40:37 +01:00
|
|
|
val = PointPriv->spriteFuncs->UnrealizeCursor(pDev, pScreen, pCur);
|
2003-11-14 17:48:57 +01:00
|
|
|
SPRITE_EPILOG;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-11-17 05:40:37 +01:00
|
|
|
RACSpriteSetCursor(DeviceIntPtr pDev, ScreenPtr pScreen,
|
|
|
|
CursorPtr pCur, int x, int y)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
SPRITE_PROLOG;
|
|
|
|
DPRINT_S("RACSpriteSetCursor",pScreen->myNum);
|
|
|
|
ENABLE;
|
2006-11-17 05:40:37 +01:00
|
|
|
PointPriv->spriteFuncs->SetCursor(pDev, pScreen, pCur, x, y);
|
2003-11-14 17:48:57 +01:00
|
|
|
SPRITE_EPILOG;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2006-11-17 05:40:37 +01:00
|
|
|
RACSpriteMoveCursor(DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
|
2003-11-14 17:48:57 +01:00
|
|
|
{
|
|
|
|
SPRITE_PROLOG;
|
|
|
|
DPRINT_S("RACSpriteMoveCursor",pScreen->myNum);
|
|
|
|
ENABLE;
|
2006-11-17 05:40:37 +01:00
|
|
|
PointPriv->spriteFuncs->MoveCursor(pDev, pScreen, x, y);
|
2003-11-14 17:48:57 +01:00
|
|
|
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
|
|
|
|
|