Merge branch 'mpx' into mdsd
Conflicts: Xi/opendev.c
This commit is contained in:
commit
184a7b8917
30
.gitignore
vendored
30
.gitignore
vendored
|
@ -16,6 +16,7 @@ config.log
|
|||
config.status
|
||||
config.sub
|
||||
configure
|
||||
configure.lineno
|
||||
depcomp
|
||||
install-sh
|
||||
libtool
|
||||
|
@ -91,6 +92,8 @@ cfb32/cfbzerarcG.c
|
|||
cfb32/cfbzerarcX.c
|
||||
doc/Xserver.1x
|
||||
doc/Xserver.man
|
||||
doc/SecurityPolicy.5
|
||||
doc/SecurityPolicy.man
|
||||
hw/dmx/Xdmx
|
||||
hw/dmx/Xdmx.1x
|
||||
hw/dmx/config/dmxtodmx
|
||||
|
@ -206,31 +209,58 @@ hw/xfree86/xaa/mf3-xaaBitmap.c
|
|||
hw/xfree86/xaa/mf3-xaaStipple.c
|
||||
hw/xfree86/xaa/s-xaaDashLine.c
|
||||
hw/xfree86/xaa/s-xaaLine.c
|
||||
hw/xfree86/xf1bpp/maskbits.c
|
||||
hw/xfree86/xf1bpp/mfbbitblt.c
|
||||
hw/xfree86/xf1bpp/mfbbltC.c
|
||||
hw/xfree86/xf1bpp/mfbbltCI.c
|
||||
hw/xfree86/xf1bpp/mfbbltG.c
|
||||
hw/xfree86/xf1bpp/mfbbltO.c
|
||||
hw/xfree86/xf1bpp/mfbbltX.c
|
||||
hw/xfree86/xf1bpp/mfbbres.c
|
||||
hw/xfree86/xf1bpp/mfbbresd.c
|
||||
hw/xfree86/xf1bpp/mfbclip.c
|
||||
hw/xfree86/xf1bpp/mfbcmap.c
|
||||
hw/xfree86/xf1bpp/mfbfillarc.c
|
||||
hw/xfree86/xf1bpp/mfbfillrct.c
|
||||
hw/xfree86/xf1bpp/mfbfillsp.c
|
||||
hw/xfree86/xf1bpp/mfbfont.c
|
||||
hw/xfree86/xf1bpp/mfbgc.c
|
||||
hw/xfree86/xf1bpp/mfbgetsp.c
|
||||
hw/xfree86/xf1bpp/mfbigbblak.c
|
||||
hw/xfree86/xf1bpp/mfbigbwht.c
|
||||
hw/xfree86/xf1bpp/mfbhrzvert.c
|
||||
hw/xfree86/xf1bpp/mfbimage.c
|
||||
hw/xfree86/xf1bpp/mfbline.c
|
||||
hw/xfree86/xf1bpp/mfbmisc.c
|
||||
hw/xfree86/xf1bpp/mfbpablack.c
|
||||
hw/xfree86/xf1bpp/mfbpainv.c
|
||||
hw/xfree86/xf1bpp/mfbpawhite.c
|
||||
hw/xfree86/xf1bpp/mfbpgbblak.c
|
||||
hw/xfree86/xf1bpp/mfbpgbinv.c
|
||||
hw/xfree86/xf1bpp/mfbpgbwht.c
|
||||
hw/xfree86/xf1bpp/mfbpixmap.c
|
||||
hw/xfree86/xf1bpp/mfbplyblack.c
|
||||
hw/xfree86/xf1bpp/mfbplyinv.c
|
||||
hw/xfree86/xf1bpp/mfbplywhite.c
|
||||
hw/xfree86/xf1bpp/mfbpntwin.c
|
||||
hw/xfree86/xf1bpp/mfbpolypnt.c
|
||||
hw/xfree86/xf1bpp/mfbpushpxl.c
|
||||
hw/xfree86/xf1bpp/mfbscrclse.c
|
||||
hw/xfree86/xf1bpp/mfbscrinit.c
|
||||
hw/xfree86/xf1bpp/mfbseg.c
|
||||
hw/xfree86/xf1bpp/mfbsetsp.c
|
||||
hw/xfree86/xf1bpp/mfbteblack.c
|
||||
hw/xfree86/xf1bpp/mfbtewhite.c
|
||||
hw/xfree86/xf1bpp/mfbtileC.c
|
||||
hw/xfree86/xf1bpp/mfbtileG.c
|
||||
hw/xfree86/xf1bpp/mfbwindow.c
|
||||
hw/xfree86/xf1bpp/mfbzerarc.c
|
||||
hw/xfree86/xf4bpp/mfbseg.c
|
||||
hw/xfree86/xf8_32bpp/cfbgc32.c
|
||||
hw/xfree86/xf8_32bpp/cfbgc8.c
|
||||
hw/xfree86/xorg.c
|
||||
hw/xfree86/xorg.conf.example
|
||||
hw/xfree86/xorg.conf.example.pre
|
||||
hw/xnest/Xnest
|
||||
hw/xnest/Xnest.1x
|
||||
hw/xnest/Xnest.man
|
||||
|
|
|
@ -1,8 +1,4 @@
|
|||
# someone could get really crazy someday and add support for the SI...
|
||||
|
||||
# xwin/darwin/xfree86 have their accel support under the DDX
|
||||
|
||||
if BUILD_DARWIN
|
||||
if XDARWIN
|
||||
DARWIN_SUBDIRS = apple
|
||||
endif
|
||||
SUBDIRS = glx mesa $(DARWIN_SUBDIRS)
|
||||
|
|
2049
GL/apple/indirect.c
2049
GL/apple/indirect.c
File diff suppressed because it is too large
Load Diff
|
@ -53,7 +53,6 @@ libglx_la_SOURCES = \
|
|||
glxserver.h \
|
||||
glxutil.c \
|
||||
glxutil.h \
|
||||
glxvisuals.c \
|
||||
indirect_dispatch.c \
|
||||
indirect_dispatch.h \
|
||||
indirect_dispatch_swap.c \
|
||||
|
|
|
@ -34,7 +34,6 @@
|
|||
** version 1.2.1 Specification.
|
||||
*/
|
||||
|
||||
extern int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
@ -42,7 +41,6 @@ extern int __glXDisp_DestroyHyperpipeConfigSGIX (__GLXclientState *cl, GLbyte *p
|
|||
extern int __glXDisp_QueryHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDisp_HyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
||||
extern int __glXDispSwap_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_BindSwapBarrierSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryMaxSwapBarriersSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
extern int __glXDispSwap_QueryHyperpipeNetworkSGIX(__GLXclientState *cl, GLbyte *pc);
|
||||
|
|
1143
GL/glx/glxcmds.c
1143
GL/glx/glxcmds.c
File diff suppressed because it is too large
Load Diff
|
@ -77,8 +77,7 @@ int __glXDispSwap_CreateContext(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->shareList);
|
||||
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->visual,
|
||||
req->screen, req->isDirect );
|
||||
return __glXDisp_CreateContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -93,8 +92,7 @@ int __glXDispSwap_CreateNewContext(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->renderType);
|
||||
__GLX_SWAP_INT(&req->shareList);
|
||||
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
|
||||
req->screen, req->isDirect );
|
||||
return __glXDisp_CreateNewContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -110,8 +108,7 @@ int __glXDispSwap_CreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->renderType);
|
||||
__GLX_SWAP_INT(&req->shareList);
|
||||
|
||||
return DoCreateContext( cl, req->context, req->shareList, req->fbconfig,
|
||||
req->screen, req->isDirect );
|
||||
return __glXDisp_CreateContextWithConfigSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyContext(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -135,8 +132,7 @@ int __glXDispSwap_MakeCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->context);
|
||||
__GLX_SWAP_INT(&req->oldContextTag);
|
||||
|
||||
return DoMakeCurrent( cl, req->drawable, req->drawable,
|
||||
req->context, req->oldContextTag );
|
||||
return __glXDisp_MakeCurrent(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -150,8 +146,7 @@ int __glXDispSwap_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->context);
|
||||
__GLX_SWAP_INT(&req->oldContextTag);
|
||||
|
||||
return DoMakeCurrent( cl, req->drawable, req->readdrawable,
|
||||
req->context, req->oldContextTag );
|
||||
return __glXDisp_MakeContextCurrent(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -165,8 +160,7 @@ int __glXDispSwap_MakeCurrentReadSGI(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->context);
|
||||
__GLX_SWAP_INT(&req->oldContextTag);
|
||||
|
||||
return DoMakeCurrent( cl, req->drawable, req->readable,
|
||||
req->context, req->oldContextTag );
|
||||
return __glXDisp_MakeCurrentReadSGI(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_IsDirect(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -233,7 +227,7 @@ int __glXDispSwap_GetVisualConfigs(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
return DoGetVisualConfigs( cl, req->screen, GL_TRUE );
|
||||
return __glXDisp_GetVisualConfigs(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -242,7 +236,7 @@ int __glXDispSwap_GetFBConfigs(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
|
||||
return __glXDisp_GetFBConfigs(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -251,7 +245,7 @@ int __glXDispSwap_GetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
return DoGetFBConfigs( cl, req->screen, GL_TRUE );
|
||||
return __glXDisp_GetFBConfigsSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -265,14 +259,15 @@ int __glXDispSwap_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->pixmap);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
|
||||
return DoCreateGLXPixmap( cl, req->visual, req->screen,
|
||||
req->pixmap, req->glxpixmap, NULL, 0 );
|
||||
return __glXDisp_CreateGLXPixmap(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
|
||||
CARD32 *attribs;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
|
||||
__GLX_SWAP_SHORT(&req->length);
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
|
@ -280,11 +275,10 @@ int __glXDispSwap_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
__GLX_SWAP_INT(&req->pixmap);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
|
||||
req->pixmap, req->glxpixmap,
|
||||
(CARD32*)(req + 1),
|
||||
req->numAttribs );
|
||||
return __glXDisp_CreatePixmap(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -299,8 +293,7 @@ int __glXDispSwap_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc
|
|||
__GLX_SWAP_INT(&req->pixmap);
|
||||
__GLX_SWAP_INT(&req->glxpixmap);
|
||||
|
||||
return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
|
||||
req->pixmap, req->glxpixmap, NULL, 0 );
|
||||
return __glXDisp_CreateGLXPixmapWithConfigSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyGLXPixmap(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -328,52 +321,123 @@ int __glXDispSwap_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
|
|||
int __glXDispSwap_QueryContext(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXQueryContextReq *req = (xGLXQueryContextReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->context);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_QueryContext(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->fbconfig);
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_CreatePbuffer(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->fbconfig);
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
__GLX_SWAP_INT(&req->width);
|
||||
__GLX_SWAP_INT(&req->height);
|
||||
|
||||
return __glXDisp_CreateGLXPbufferSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
return BadRequest;
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
|
||||
return __glXDisp_DestroyPbuffer(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
__GLX_SWAP_INT(&req->pbuffer);
|
||||
|
||||
return __glXDisp_DestroyGLXPbufferSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXChangeDrawableAttributesReq *req =
|
||||
(xGLXChangeDrawableAttributesReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
return BadRequest;
|
||||
__GLX_SWAP_INT(&req->drawable);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return __glXDisp_ChangeDrawableAttributes(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
|
||||
GLbyte *pc)
|
||||
{
|
||||
xGLXChangeDrawableAttributesSGIXReq *req =
|
||||
(xGLXChangeDrawableAttributesSGIXReq *) req;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
__GLX_SWAP_INT(&req->drawable);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return __glXDisp_ChangeDrawableAttributesSGIX(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
|
||||
CARD32 *attribs;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->screen);
|
||||
__GLX_SWAP_INT(&req->fbconfig);
|
||||
__GLX_SWAP_INT(&req->window);
|
||||
__GLX_SWAP_INT(&req->glxwindow);
|
||||
__GLX_SWAP_INT(&req->numAttribs);
|
||||
attribs = (CARD32*)(req + 1);
|
||||
__GLX_SWAP_INT_ARRAY(attribs, req->numAttribs);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_CreateWindow(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
|
||||
__GLX_DECLARE_SWAP_VARIABLES;
|
||||
|
||||
(void) req;
|
||||
__GLX_SWAP_INT(&req->glxwindow);
|
||||
|
||||
return BadRequest;
|
||||
return __glXDisp_DestroyWindow(cl, pc);
|
||||
}
|
||||
|
||||
int __glXDispSwap_SwapBuffers(__GLXclientState *cl, GLbyte *pc)
|
||||
|
@ -643,7 +707,7 @@ void __glXSwapGetDrawableAttributesReply(ClientPtr client,
|
|||
|
||||
int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return DoRender(cl, pc, True);
|
||||
return __glXDisp_Render(cl, pc);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -651,7 +715,7 @@ int __glXDispSwap_Render(__GLXclientState *cl, GLbyte *pc)
|
|||
*/
|
||||
int __glXDispSwap_RenderLarge(__GLXclientState *cl, GLbyte *pc)
|
||||
{
|
||||
return DoRenderLarge(cl, pc, True);
|
||||
return __glXDisp_RenderLarge(cl, pc);
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
|
|
@ -44,12 +44,12 @@
|
|||
|
||||
typedef struct __GLXtextureFromPixmap __GLXtextureFromPixmap;
|
||||
struct __GLXtextureFromPixmap {
|
||||
int (*bindTexImage) (__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *pixmap);
|
||||
int (*releaseTexImage) (__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *pixmap);
|
||||
int (*bindTexImage) (__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXdrawable *pixmap);
|
||||
int (*releaseTexImage) (__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXdrawable *pixmap);
|
||||
};
|
||||
|
||||
|
||||
|
@ -85,14 +85,8 @@ struct __GLXcontext {
|
|||
** Pointer to screen info data for this context. This is set
|
||||
** when the context is created.
|
||||
*/
|
||||
ScreenPtr pScreen;
|
||||
__GLXscreen *pGlxScreen;
|
||||
|
||||
/*
|
||||
** This context is created with respect to this visual.
|
||||
*/
|
||||
VisualRec *pVisual;
|
||||
|
||||
/*
|
||||
** The XID of this context.
|
||||
*/
|
||||
|
@ -103,11 +97,6 @@ struct __GLXcontext {
|
|||
*/
|
||||
XID share_id;
|
||||
|
||||
/*
|
||||
** Visual id.
|
||||
*/
|
||||
VisualID vid;
|
||||
|
||||
/*
|
||||
** screen number.
|
||||
*/
|
||||
|
@ -128,11 +117,6 @@ struct __GLXcontext {
|
|||
*/
|
||||
GLboolean isDirect;
|
||||
|
||||
/*
|
||||
** Window pending state
|
||||
*/
|
||||
GLuint pendingState;
|
||||
|
||||
/*
|
||||
** This flag keeps track of whether there are unflushed GL commands.
|
||||
*/
|
||||
|
@ -151,12 +135,6 @@ struct __GLXcontext {
|
|||
GLuint *selectBuf;
|
||||
GLint selectBufSize; /* number of elements allocated */
|
||||
|
||||
/*
|
||||
** Set only if current drawable is a glx pixmap.
|
||||
*/
|
||||
__GLXpixmap *drawPixmap;
|
||||
__GLXpixmap *readPixmap;
|
||||
|
||||
/*
|
||||
** The drawable private this context is bound to
|
||||
*/
|
||||
|
|
|
@ -42,26 +42,12 @@
|
|||
|
||||
#include <damage.h>
|
||||
|
||||
#ifdef XF86DRI
|
||||
#include <GL/internal/dri_interface.h>
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
|
||||
DrawablePtr pDraw;
|
||||
__GLcontextModes *modes;
|
||||
__GLXscreen *pGlxScreen;
|
||||
ScreenPtr pScreen;
|
||||
Bool idExists;
|
||||
int refcnt;
|
||||
GLenum target;
|
||||
#ifdef XF86DRI
|
||||
DamagePtr pDamage;
|
||||
__DRIcontext *pDRICtx;
|
||||
GLint texname;
|
||||
unsigned long offset;
|
||||
#endif
|
||||
} __GLXpixmap;
|
||||
/* We just need to avoid clashing with DRAWABLE_{WINDOW,PIXMAP} */
|
||||
enum {
|
||||
GLX_DRAWABLE_WINDOW,
|
||||
GLX_DRAWABLE_PIXMAP,
|
||||
GLX_DRAWABLE_PBUFFER
|
||||
};
|
||||
|
||||
struct __GLXdrawable {
|
||||
void (*destroy)(__GLXdrawable *private);
|
||||
|
@ -78,12 +64,10 @@ struct __GLXdrawable {
|
|||
|
||||
DrawablePtr pDraw;
|
||||
XID drawId;
|
||||
__GLXpixmap *pGlxPixmap;
|
||||
|
||||
/*
|
||||
** Either DRAWABLE_PIXMAP or DRAWABLE_WINDOW, copied from pDraw above.
|
||||
** Needed by the resource freer because pDraw might already have been
|
||||
** freed.
|
||||
** Either GLX_DRAWABLE_PIXMAP, GLX_DRAWABLE_WINDOW or
|
||||
** GLX_DRAWABLE_PBUFFER.
|
||||
*/
|
||||
int type;
|
||||
|
||||
|
@ -105,6 +89,13 @@ struct __GLXdrawable {
|
|||
** reference count
|
||||
*/
|
||||
int refCount;
|
||||
|
||||
GLenum target;
|
||||
|
||||
/*
|
||||
** Event mask
|
||||
*/
|
||||
unsigned long eventMask;
|
||||
};
|
||||
|
||||
#endif /* !__GLX_drawable_h__ */
|
||||
|
|
629
GL/glx/glxdri.c
629
GL/glx/glxdri.c
|
@ -59,77 +59,55 @@
|
|||
#include "dispatch.h"
|
||||
#include "extension_string.h"
|
||||
|
||||
#define containerOf(ptr, type, member) \
|
||||
(type *)( (char *)ptr - offsetof(type,member) )
|
||||
|
||||
#define STRINGIFY(macro_or_string) STRINGIFY_ARG (macro_or_string)
|
||||
#define STRINGIFY_ARG(contents) #contents
|
||||
|
||||
typedef struct __GLXDRIscreen __GLXDRIscreen;
|
||||
typedef struct __GLXDRIcontext __GLXDRIcontext;
|
||||
typedef struct __GLXDRIscreen __GLXDRIscreen;
|
||||
typedef struct __GLXDRIcontext __GLXDRIcontext;
|
||||
typedef struct __GLXDRIdrawable __GLXDRIdrawable;
|
||||
|
||||
struct __GLXDRIscreen {
|
||||
__GLXscreen base;
|
||||
__DRIscreen driScreen;
|
||||
void *driver;
|
||||
|
||||
__DRIscreen driScreen;
|
||||
void *driver;
|
||||
xf86EnterVTProc *enterVT;
|
||||
xf86LeaveVTProc *leaveVT;
|
||||
|
||||
xf86EnterVTProc *enterVT;
|
||||
xf86LeaveVTProc *leaveVT;
|
||||
__DRIcopySubBufferExtension *copySubBuffer;
|
||||
__DRIswapControlExtension *swapControl;
|
||||
|
||||
#ifdef __DRI_TEX_OFFSET
|
||||
__DRItexOffsetExtension *texOffset;
|
||||
DRITexOffsetStartProcPtr texOffsetStart;
|
||||
DRITexOffsetFinishProcPtr texOffsetFinish;
|
||||
__GLXpixmap* texOffsetOverride[16];
|
||||
__GLXDRIdrawable *texOffsetOverride[16];
|
||||
GLuint lastTexOffsetOverride;
|
||||
#endif
|
||||
|
||||
unsigned char glx_enable_bits[__GLX_EXT_BYTES];
|
||||
};
|
||||
|
||||
struct __GLXDRIcontext {
|
||||
__GLXcontext base;
|
||||
|
||||
__DRIcontext driContext;
|
||||
__GLXcontext base;
|
||||
__DRIcontext driContext;
|
||||
XID hwContextID;
|
||||
};
|
||||
|
||||
struct __GLXDRIdrawable {
|
||||
__GLXdrawable base;
|
||||
__GLXdrawable base;
|
||||
__DRIdrawable driDrawable;
|
||||
|
||||
__DRIdrawable *driDrawable;
|
||||
/* Pulled in from old __GLXpixmap */
|
||||
#ifdef __DRI_TEX_OFFSET
|
||||
GLint texname;
|
||||
__GLXDRIcontext *ctx;
|
||||
unsigned long offset;
|
||||
DamagePtr pDamage;
|
||||
#endif
|
||||
};
|
||||
|
||||
/* History:
|
||||
* 20021121 - Initial version
|
||||
* 20021128 - Added __glXWindowExists() function
|
||||
* 20021207 - Added support for dynamic GLX extensions,
|
||||
* GLX_SGI_swap_control, GLX_SGI_video_sync,
|
||||
* GLX_OML_sync_control, and GLX_MESA_swap_control.
|
||||
* Never officially released. Do NOT test against
|
||||
* this version. Use 20030317 instead.
|
||||
* 20030317 - Added support GLX_SGIX_fbconfig,
|
||||
* GLX_MESA_swap_frame_usage, GLX_OML_swap_method,
|
||||
* GLX_{ARB,SGIS}_multisample, and
|
||||
* GLX_SGIX_visual_select_group.
|
||||
* 20030606 - Added support for GLX_SGI_make_current_read.
|
||||
* 20030813 - Made support for dynamic extensions multi-head aware.
|
||||
* 20030818 - Added support for GLX_MESA_allocate_memory in place of the
|
||||
* deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset
|
||||
* interfaces.
|
||||
* 20031201 - Added support for the first round of DRI interface changes.
|
||||
* Do NOT test against this version! It has binary
|
||||
* compatibility bugs, use 20040317 instead.
|
||||
* 20040317 - Added the 'mode' field to __DRIcontextRec.
|
||||
* 20040415 - Added support for bindContext3 and unbindContext3.
|
||||
* 20040602 - Add __glXGetDrawableInfo. I though that was there
|
||||
* months ago. :(
|
||||
* 20050727 - Gut all the old interfaces. This breaks compatability with
|
||||
* any DRI driver built to any previous version.
|
||||
* 20060314 - Added support for GLX_MESA_copy_sub_buffer.
|
||||
*/
|
||||
|
||||
#define INTERNAL_VERSION 20050727
|
||||
|
||||
static const char CREATE_NEW_SCREEN_FUNC[] =
|
||||
"__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION);
|
||||
|
||||
static const char CREATE_NEW_SCREEN_FUNC[] = __DRI_CREATE_NEW_SCREEN_STRING;
|
||||
|
||||
static void
|
||||
__glXDRIleaveServer(GLboolean rendering)
|
||||
|
@ -138,19 +116,19 @@ __glXDRIleaveServer(GLboolean rendering)
|
|||
|
||||
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(i);
|
||||
(__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
|
||||
GLuint lastOverride = screen->lastTexOffsetOverride;
|
||||
|
||||
if (lastOverride) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < lastOverride; j++) {
|
||||
__GLXpixmap *pGlxPix = texOffsetOverride[j];
|
||||
__GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
|
||||
|
||||
if (pGlxPix && pGlxPix->texname) {
|
||||
pGlxPix->offset =
|
||||
screen->texOffsetStart((PixmapPtr)pGlxPix->pDraw);
|
||||
screen->texOffsetStart((PixmapPtr)pGlxPix->base.pDraw);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -160,23 +138,22 @@ __glXDRIleaveServer(GLboolean rendering)
|
|||
|
||||
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(i);
|
||||
(__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
|
||||
GLuint lastOverride = screen->lastTexOffsetOverride;
|
||||
|
||||
if (lastOverride) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < lastOverride; j++) {
|
||||
__GLXpixmap *pGlxPix = texOffsetOverride[j];
|
||||
__GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
|
||||
|
||||
if (pGlxPix && pGlxPix->texname) {
|
||||
screen->driScreen.setTexOffset(pGlxPix->pDRICtx,
|
||||
pGlxPix->texname,
|
||||
pGlxPix->offset,
|
||||
pGlxPix->pDraw->depth,
|
||||
((PixmapPtr)pGlxPix->pDraw)->
|
||||
devKind);
|
||||
screen->texOffset->setTexOffset(&pGlxPix->ctx->driContext,
|
||||
pGlxPix->texname,
|
||||
pGlxPix->offset,
|
||||
pGlxPix->base.pDraw->depth,
|
||||
((PixmapPtr)pGlxPix->base.pDraw)->devKind);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -189,8 +166,8 @@ __glXDRIenterServer(GLboolean rendering)
|
|||
int i;
|
||||
|
||||
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(i);
|
||||
__GLXDRIscreen * const screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(screenInfo.screens[i]);
|
||||
|
||||
if (screen->lastTexOffsetOverride) {
|
||||
CALL_Flush(GET_DISPATCH(), ());
|
||||
|
@ -201,29 +178,21 @@ __glXDRIenterServer(GLboolean rendering)
|
|||
DRIWakeupHandler(NULL, 0, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* \bug
|
||||
* We're jumping through hoops here to get the DRIdrawable which the DRI
|
||||
* driver tries to keep to it self... cf. FIXME in \c createDrawable.
|
||||
*/
|
||||
static void
|
||||
__glXDRIdrawableFoo(__GLXDRIdrawable *draw)
|
||||
__glXDRIdrawableDestroy(__GLXdrawable *drawable)
|
||||
{
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(draw->base.pDraw->pScreen->myNum);
|
||||
__GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
|
||||
|
||||
draw->driDrawable = (*screen->driScreen.getDrawable)(NULL,
|
||||
draw->base.drawId,
|
||||
screen->driScreen.private);
|
||||
}
|
||||
(*private->driDrawable.destroyDrawable)(&private->driDrawable);
|
||||
|
||||
static void
|
||||
__glXDRIdrawableDestroy(__GLXdrawable *private)
|
||||
{
|
||||
#if 0
|
||||
(*glxPriv->driDrawable.destroyDrawable)(NULL,
|
||||
glxPriv->driDrawable.private);
|
||||
#endif
|
||||
/* If the X window was destroyed, the dri DestroyWindow hook will
|
||||
* aready have taken care of this, so only call if pDraw isn't NULL. */
|
||||
if (drawable->pDraw != NULL) {
|
||||
__glXenterServer(GL_FALSE);
|
||||
DRIDestroyDrawable(drawable->pDraw->pScreen,
|
||||
serverClient, drawable->pDraw);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
}
|
||||
|
||||
xfree(private);
|
||||
}
|
||||
|
@ -242,10 +211,7 @@ __glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate)
|
|||
{
|
||||
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
|
||||
|
||||
__glXDRIdrawableFoo(private);
|
||||
|
||||
(*private->driDrawable->swapBuffers)(NULL,
|
||||
private->driDrawable->private);
|
||||
(*private->driDrawable.swapBuffers)(&private->driDrawable);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -255,10 +221,12 @@ static int
|
|||
__glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
|
||||
{
|
||||
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(baseDrawable->pDraw->pScreen);
|
||||
|
||||
__glXDRIdrawableFoo(draw);
|
||||
if (screen->swapControl)
|
||||
screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
|
||||
|
||||
draw->driDrawable->swap_interval = interval;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -268,22 +236,26 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate,
|
|||
int x, int y, int w, int h)
|
||||
{
|
||||
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(basePrivate->pDraw->pScreen);
|
||||
|
||||
__glXDRIdrawableFoo(private);
|
||||
|
||||
(*private->driDrawable->copySubBuffer)(NULL,
|
||||
private->driDrawable->private,
|
||||
x, y, w, h);
|
||||
if (screen->copySubBuffer)
|
||||
screen->copySubBuffer->copySubBuffer(&private->driDrawable,
|
||||
x, y, w, h);
|
||||
}
|
||||
|
||||
static void
|
||||
__glXDRIcontextDestroy(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
Bool retval;
|
||||
|
||||
context->driContext.destroyContext(&context->driContext);
|
||||
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRIDestroyContext(baseContext->pGlxScreen->pScreen, context->hwContextID);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
context->driContext.destroyContext(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
context->driContext.private);
|
||||
__glXContextDestroy(&context->base);
|
||||
xfree(context);
|
||||
}
|
||||
|
@ -292,24 +264,20 @@ static int
|
|||
__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
|
||||
__GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
|
||||
|
||||
return (*context->driContext.bindContext)(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
baseContext->drawPriv->drawId,
|
||||
baseContext->readPriv->drawId,
|
||||
&context->driContext);
|
||||
}
|
||||
return (*context->driContext.bindContext)(&context->driContext,
|
||||
&draw->driDrawable,
|
||||
&read->driDrawable);
|
||||
}
|
||||
|
||||
static int
|
||||
__glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
|
||||
return (*context->driContext.unbindContext)(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
baseContext->drawPriv->drawId,
|
||||
baseContext->readPriv->drawId,
|
||||
&context->driContext);
|
||||
return (*context->driContext.unbindContext)(&context->driContext);
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -331,12 +299,12 @@ static int
|
|||
__glXDRIcontextForceCurrent(__GLXcontext *baseContext)
|
||||
{
|
||||
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
|
||||
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
|
||||
__GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
|
||||
|
||||
return (*context->driContext.bindContext)(NULL,
|
||||
context->base.pScreen->myNum,
|
||||
baseContext->drawPriv->drawId,
|
||||
baseContext->readPriv->drawId,
|
||||
&context->driContext);
|
||||
return (*context->driContext.bindContext)(&context->driContext,
|
||||
&draw->driDrawable,
|
||||
&read->driDrawable);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -370,24 +338,34 @@ glxFillAlphaChannel (PixmapPtr pixmap, int x, int y, int width, int height)
|
|||
static int
|
||||
__glXDRIbindTexImage(__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *glxPixmap)
|
||||
__GLXdrawable *glxPixmap)
|
||||
{
|
||||
RegionPtr pRegion = NULL;
|
||||
PixmapPtr pixmap;
|
||||
int bpp, override = 0;
|
||||
int bpp, override = 0, texname;
|
||||
GLenum format, type;
|
||||
ScreenPtr pScreen = glxPixmap->pScreen;
|
||||
ScreenPtr pScreen = glxPixmap->pDraw->pScreen;
|
||||
__GLXDRIdrawable *driDraw =
|
||||
containerOf(glxPixmap, __GLXDRIdrawable, base);
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
|
||||
(__GLXDRIscreen *) glxGetScreen(pScreen);
|
||||
|
||||
CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
|
||||
GL_TEXTURE_BINDING_2D :
|
||||
GL_TEXTURE_BINDING_RECTANGLE_NV,
|
||||
&texname));
|
||||
|
||||
if (!texname)
|
||||
return __glXError(GLXBadContextState);
|
||||
|
||||
pixmap = (PixmapPtr) glxPixmap->pDraw;
|
||||
|
||||
if (screen->texOffsetStart && screen->driScreen.setTexOffset) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
int i, firstEmpty = 16, texname;
|
||||
if (screen->texOffsetStart && screen->texOffset) {
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int i, firstEmpty = 16;
|
||||
|
||||
for (i = 0; i < 16; i++) {
|
||||
if (texOffsetOverride[i] == glxPixmap)
|
||||
if (texOffsetOverride[i] == driDraw)
|
||||
goto alreadyin;
|
||||
|
||||
if (firstEmpty == 16 && !texOffsetOverride[i])
|
||||
|
@ -402,41 +380,37 @@ __glXDRIbindTexImage(__GLXcontext *baseContext,
|
|||
if (firstEmpty >= screen->lastTexOffsetOverride)
|
||||
screen->lastTexOffsetOverride = firstEmpty + 1;
|
||||
|
||||
texOffsetOverride[firstEmpty] = glxPixmap;
|
||||
texOffsetOverride[firstEmpty] = driDraw;
|
||||
|
||||
alreadyin:
|
||||
override = 1;
|
||||
|
||||
glxPixmap->pDRICtx = &((__GLXDRIcontext*)baseContext)->driContext;
|
||||
driDraw->ctx = (__GLXDRIcontext*)baseContext;
|
||||
|
||||
CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
|
||||
GL_TEXTURE_BINDING_2D :
|
||||
GL_TEXTURE_BINDING_RECTANGLE_NV,
|
||||
&texname));
|
||||
|
||||
if (texname == glxPixmap->texname)
|
||||
if (texname == driDraw->texname)
|
||||
return Success;
|
||||
|
||||
glxPixmap->texname = texname;
|
||||
driDraw->texname = texname;
|
||||
|
||||
screen->driScreen.setTexOffset(glxPixmap->pDRICtx, texname, 0,
|
||||
pixmap->drawable.depth, pixmap->devKind);
|
||||
screen->texOffset->setTexOffset(&driDraw->ctx->driContext, texname, 0,
|
||||
pixmap->drawable.depth,
|
||||
pixmap->devKind);
|
||||
}
|
||||
nooverride:
|
||||
|
||||
if (!glxPixmap->pDamage) {
|
||||
if (!driDraw->pDamage) {
|
||||
if (!override) {
|
||||
glxPixmap->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
|
||||
TRUE, pScreen, NULL);
|
||||
if (!glxPixmap->pDamage)
|
||||
driDraw->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
|
||||
TRUE, pScreen, NULL);
|
||||
if (!driDraw->pDamage)
|
||||
return BadAlloc;
|
||||
|
||||
DamageRegister ((DrawablePtr) pixmap, glxPixmap->pDamage);
|
||||
DamageRegister ((DrawablePtr) pixmap, driDraw->pDamage);
|
||||
}
|
||||
|
||||
pRegion = NULL;
|
||||
} else {
|
||||
pRegion = DamageRegion(glxPixmap->pDamage);
|
||||
pRegion = DamageRegion(driDraw->pDamage);
|
||||
if (REGION_NIL(pRegion))
|
||||
return Success;
|
||||
}
|
||||
|
@ -515,7 +489,7 @@ nooverride:
|
|||
}
|
||||
|
||||
if (!override)
|
||||
DamageEmpty(glxPixmap->pDamage);
|
||||
DamageEmpty(driDraw->pDamage);
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
@ -523,19 +497,21 @@ nooverride:
|
|||
static int
|
||||
__glXDRIreleaseTexImage(__GLXcontext *baseContext,
|
||||
int buffer,
|
||||
__GLXpixmap *pixmap)
|
||||
__GLXdrawable *pixmap)
|
||||
{
|
||||
ScreenPtr pScreen = pixmap->pScreen;
|
||||
ScreenPtr pScreen = pixmap->pDraw->pScreen;
|
||||
__GLXDRIdrawable *driDraw =
|
||||
containerOf(pixmap, __GLXDRIdrawable, base);
|
||||
__GLXDRIscreen * const screen =
|
||||
(__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
|
||||
(__GLXDRIscreen *) glxGetScreen(pScreen);
|
||||
GLuint lastOverride = screen->lastTexOffsetOverride;
|
||||
|
||||
if (lastOverride) {
|
||||
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
|
||||
__GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < lastOverride; i++) {
|
||||
if (texOffsetOverride[i] == pixmap) {
|
||||
if (texOffsetOverride[i] == driDraw) {
|
||||
if (screen->texOffsetFinish)
|
||||
screen->texOffsetFinish((PixmapPtr)pixmap->pDraw);
|
||||
|
||||
|
@ -572,9 +548,7 @@ __glXDRIscreenDestroy(__GLXscreen *baseScreen)
|
|||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
|
||||
screen->driScreen.destroyScreen(NULL,
|
||||
screen->base.pScreen->myNum,
|
||||
screen->driScreen.private);
|
||||
screen->driScreen.destroyScreen(&screen->driScreen);
|
||||
|
||||
dlclose(screen->driver);
|
||||
|
||||
|
@ -590,13 +564,18 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
|
|||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
|
||||
__GLXDRIcontext *context, *shareContext;
|
||||
void *sharePrivate;
|
||||
VisualPtr visual;
|
||||
int i;
|
||||
GLboolean retval;
|
||||
__DRIcontext *driShare;
|
||||
drm_context_t hwContext;
|
||||
ScreenPtr pScreen = baseScreen->pScreen;
|
||||
|
||||
shareContext = (__GLXDRIcontext *) baseShareContext;
|
||||
if (shareContext)
|
||||
sharePrivate = shareContext->driContext.private;
|
||||
driShare = &shareContext->driContext;
|
||||
else
|
||||
sharePrivate = NULL;
|
||||
driShare = NULL;
|
||||
|
||||
context = xalloc(sizeof *context);
|
||||
if (context == NULL)
|
||||
|
@ -608,28 +587,45 @@ __glXDRIscreenCreateContext(__GLXscreen *baseScreen,
|
|||
context->base.loseCurrent = __glXDRIcontextLoseCurrent;
|
||||
context->base.copy = __glXDRIcontextCopy;
|
||||
context->base.forceCurrent = __glXDRIcontextForceCurrent;
|
||||
context->base.pScreen = screen->base.pScreen;
|
||||
|
||||
context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
|
||||
/* Find the requested X visual */
|
||||
visual = pScreen->visuals;
|
||||
for (i = 0; i < pScreen->numVisuals; i++, visual++)
|
||||
if (visual->vid == modes->visualID)
|
||||
break;
|
||||
if (i == pScreen->numVisuals)
|
||||
return GL_FALSE;
|
||||
|
||||
context->hwContextID = FakeClientID(0);
|
||||
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRICreateContext(baseScreen->pScreen, visual,
|
||||
context->hwContextID, &hwContext);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
context->driContext.private =
|
||||
screen->driScreen.createNewContext(NULL, modes,
|
||||
screen->driScreen.createNewContext(&screen->driScreen,
|
||||
modes,
|
||||
0, /* render type */
|
||||
sharePrivate,
|
||||
driShare,
|
||||
hwContext,
|
||||
&context->driContext);
|
||||
|
||||
context->driContext.mode = modes;
|
||||
|
||||
return &context->base;
|
||||
}
|
||||
|
||||
static __GLXdrawable *
|
||||
__glXDRIscreenCreateDrawable(__GLXscreen *screen,
|
||||
DrawablePtr pDraw,
|
||||
int type,
|
||||
XID drawId,
|
||||
__GLcontextModes *modes)
|
||||
{
|
||||
__GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
|
||||
__GLXDRIdrawable *private;
|
||||
GLboolean retval;
|
||||
drm_drawable_t hwDrawable;
|
||||
|
||||
private = xalloc(sizeof *private);
|
||||
if (private == NULL)
|
||||
|
@ -637,7 +633,8 @@ __glXDRIscreenCreateDrawable(__GLXscreen *screen,
|
|||
|
||||
memset(private, 0, sizeof *private);
|
||||
|
||||
if (!__glXDrawableInit(&private->base, screen, pDraw, drawId, modes)) {
|
||||
if (!__glXDrawableInit(&private->base, screen,
|
||||
pDraw, type, drawId, modes)) {
|
||||
xfree(private);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -647,238 +644,50 @@ __glXDRIscreenCreateDrawable(__GLXscreen *screen,
|
|||
private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
|
||||
private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
|
||||
|
||||
#if 0
|
||||
/* FIXME: It would only be natural that we called
|
||||
* driScreen->createNewDrawable here but the DRI drivers manage
|
||||
* them a little oddly. FIXME: describe this better.*/
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRICreateDrawable(screen->pScreen, serverClient,
|
||||
pDraw, &hwDrawable);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
/* The last argument is 'attrs', which is used with pbuffers which
|
||||
* we currently don't support. */
|
||||
|
||||
glxPriv->driDrawable.private =
|
||||
(screen->driScreen.createNewDrawable)(NULL, modes,
|
||||
drawId,
|
||||
&glxPriv->driDrawable,
|
||||
0,
|
||||
NULL);
|
||||
#endif
|
||||
private->driDrawable.private =
|
||||
(driScreen->driScreen.createNewDrawable)(&driScreen->driScreen,
|
||||
modes,
|
||||
&private->driDrawable,
|
||||
hwDrawable, 0, NULL);
|
||||
|
||||
return &private->base;
|
||||
}
|
||||
|
||||
|
||||
static unsigned
|
||||
filter_modes(__GLcontextModes **server_modes,
|
||||
const __GLcontextModes *driver_modes)
|
||||
{
|
||||
__GLcontextModes * m;
|
||||
__GLcontextModes ** prev_next;
|
||||
const __GLcontextModes * check;
|
||||
unsigned modes_count = 0;
|
||||
|
||||
if ( driver_modes == NULL ) {
|
||||
LogMessage(X_WARNING,
|
||||
"AIGLX: 3D driver returned no fbconfigs.\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* For each mode in server_modes, check to see if a matching mode exists
|
||||
* in driver_modes. If not, then the mode is not available.
|
||||
*/
|
||||
|
||||
prev_next = server_modes;
|
||||
for ( m = *prev_next ; m != NULL ; m = *prev_next ) {
|
||||
GLboolean do_delete = GL_TRUE;
|
||||
|
||||
for ( check = driver_modes ; check != NULL ; check = check->next ) {
|
||||
if ( _gl_context_modes_are_same( m, check ) ) {
|
||||
do_delete = GL_FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* The 3D has to support all the modes that match the GLX visuals
|
||||
* sent from the X server.
|
||||
*/
|
||||
if ( do_delete && (m->visualID != 0) ) {
|
||||
do_delete = GL_FALSE;
|
||||
|
||||
LogMessage(X_WARNING,
|
||||
"AIGLX: 3D driver claims to not support "
|
||||
"visual 0x%02x\n", m->visualID);
|
||||
}
|
||||
|
||||
if ( do_delete ) {
|
||||
*prev_next = m->next;
|
||||
|
||||
m->next = NULL;
|
||||
_gl_context_modes_destroy( m );
|
||||
}
|
||||
else {
|
||||
modes_count++;
|
||||
prev_next = & m->next;
|
||||
}
|
||||
}
|
||||
|
||||
return modes_count;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
enable_glx_extension(void *psc, const char *ext_name)
|
||||
{
|
||||
__GLXDRIscreen * const screen = (__GLXDRIscreen *) psc;
|
||||
|
||||
__glXEnableExtension(screen->glx_enable_bits, ext_name);
|
||||
}
|
||||
|
||||
|
||||
static __DRIfuncPtr getProcAddress(const char *proc_name)
|
||||
{
|
||||
if (strcmp(proc_name, "glxEnableExtension") == 0) {
|
||||
return (__DRIfuncPtr) enable_glx_extension;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(scrn);
|
||||
|
||||
return &screen->driScreen;
|
||||
}
|
||||
|
||||
static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw)
|
||||
{
|
||||
DrawablePtr pDrawable = (DrawablePtr) LookupIDByType(draw, RT_WINDOW);
|
||||
int unused;
|
||||
drm_clip_rect_t *pRects;
|
||||
|
||||
return pDrawable ? DRIGetDrawableInfo(pDrawable->pScreen, pDrawable,
|
||||
(unsigned*)&unused, (unsigned*)&unused,
|
||||
&unused, &unused, &unused, &unused,
|
||||
&unused, &pRects, &unused, &unused,
|
||||
&unused, &pRects)
|
||||
: GL_FALSE;
|
||||
}
|
||||
|
||||
static GLboolean createContext(__DRInativeDisplay *dpy, int screen,
|
||||
int configID, void *contextID,
|
||||
drm_context_t *hw_context)
|
||||
{
|
||||
XID fakeID;
|
||||
VisualPtr visual;
|
||||
int i;
|
||||
ScreenPtr pScreen;
|
||||
GLboolean retval;
|
||||
|
||||
pScreen = screenInfo.screens[screen];
|
||||
|
||||
/* Find the requested X visual */
|
||||
visual = pScreen->visuals;
|
||||
for (i = 0; i < pScreen->numVisuals; i++, visual++)
|
||||
if (visual->vid == configID)
|
||||
break;
|
||||
if (i == pScreen->numVisuals)
|
||||
return GL_FALSE;
|
||||
|
||||
fakeID = FakeClientID(0);
|
||||
*(XID *) contextID = fakeID;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRICreateContext(pScreen, visual, fakeID, hw_context);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen,
|
||||
__DRIid context)
|
||||
{
|
||||
GLboolean retval;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRIDestroyContext(screenInfo.screens[screen], context);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
createDrawable(__DRInativeDisplay *dpy, int screen,
|
||||
__DRIid drawable, drm_drawable_t *hHWDrawable)
|
||||
{
|
||||
DrawablePtr pDrawable;
|
||||
GLboolean retval;
|
||||
|
||||
pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
|
||||
if (!pDrawable)
|
||||
return GL_FALSE;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRICreateDrawable(screenInfo.screens[screen], __pGlxClient,
|
||||
pDrawable, hHWDrawable);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
destroyDrawable(__DRInativeDisplay *dpy, int screen, __DRIid drawable)
|
||||
{
|
||||
DrawablePtr pDrawable;
|
||||
GLboolean retval;
|
||||
|
||||
pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
|
||||
if (!pDrawable)
|
||||
return GL_FALSE;
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRIDestroyDrawable(screenInfo.screens[screen], __pGlxClient,
|
||||
pDrawable);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static GLboolean
|
||||
getDrawableInfo(__DRInativeDisplay *dpy, int screen,
|
||||
__DRIid drawable, unsigned int *index, unsigned int *stamp,
|
||||
getDrawableInfo(__DRIdrawable *driDrawable,
|
||||
unsigned int *index, unsigned int *stamp,
|
||||
int *x, int *y, int *width, int *height,
|
||||
int *numClipRects, drm_clip_rect_t **ppClipRects,
|
||||
int *backX, int *backY,
|
||||
int *numBackClipRects, drm_clip_rect_t **ppBackClipRects)
|
||||
{
|
||||
DrawablePtr pDrawable;
|
||||
__GLXDRIdrawable *drawable = containerOf(driDrawable,
|
||||
__GLXDRIdrawable, driDrawable);
|
||||
ScreenPtr pScreen;
|
||||
drm_clip_rect_t *pClipRects, *pBackClipRects;
|
||||
GLboolean retval;
|
||||
size_t size;
|
||||
|
||||
pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
|
||||
if (!pDrawable) {
|
||||
ErrorF("getDrawableInfo failed to look up window\n");
|
||||
|
||||
*index = 0;
|
||||
*stamp = 0;
|
||||
*x = 0;
|
||||
*y = 0;
|
||||
*width = 0;
|
||||
*height = 0;
|
||||
*numClipRects = 0;
|
||||
*ppClipRects = NULL;
|
||||
*backX = 0;
|
||||
*backY = 0;
|
||||
*numBackClipRects = 0;
|
||||
*ppBackClipRects = NULL;
|
||||
|
||||
/* If the X window has been destroyed, give up here. */
|
||||
if (drawable->base.pDraw == NULL)
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
__glXDRIenterServer(GL_FALSE);
|
||||
retval = DRIGetDrawableInfo(screenInfo.screens[screen],
|
||||
pDrawable, index, stamp,
|
||||
pScreen = drawable->base.pDraw->pScreen;
|
||||
__glXenterServer(GL_FALSE);
|
||||
retval = DRIGetDrawableInfo(pScreen, drawable->base.pDraw, index, stamp,
|
||||
x, y, width, height,
|
||||
numClipRects, &pClipRects,
|
||||
backX, backY,
|
||||
numBackClipRects, &pBackClipRects);
|
||||
__glXDRIleaveServer(GL_FALSE);
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
||||
if (*numClipRects > 0) {
|
||||
size = sizeof (drm_clip_rect_t) * *numClipRects;
|
||||
|
@ -886,7 +695,6 @@ getDrawableInfo(__DRInativeDisplay *dpy, int screen,
|
|||
|
||||
/* Clip cliprects to screen dimensions (redirected windows) */
|
||||
if (*ppClipRects != NULL) {
|
||||
ScreenPtr pScreen = screenInfo.screens[screen];
|
||||
int i, j;
|
||||
|
||||
for (i = 0, j = 0; i < *numClipRects; i++) {
|
||||
|
@ -943,25 +751,33 @@ getUST(int64_t *ust)
|
|||
}
|
||||
}
|
||||
|
||||
static void __glXReportDamage(__DRIdrawable *driDraw,
|
||||
int x, int y,
|
||||
drm_clip_rect_t *rects, int num_rects,
|
||||
GLboolean front_buffer)
|
||||
{
|
||||
__GLXDRIdrawable *drawable =
|
||||
containerOf(driDraw, __GLXDRIdrawable, driDrawable);
|
||||
DrawablePtr pDraw = drawable->base.pDraw;
|
||||
RegionRec region;
|
||||
|
||||
REGION_INIT(pDraw->pScreen, ®ion, (BoxPtr) rects, num_rects);
|
||||
REGION_TRANSLATE(pScreen, ®ion, pDraw->x, pDraw->y);
|
||||
DamageDamageRegion(pDraw, ®ion);
|
||||
REGION_UNINIT(pDraw->pScreen, ®ion);
|
||||
}
|
||||
|
||||
/* Table of functions that we export to the driver. */
|
||||
static const __DRIinterfaceMethods interface_methods = {
|
||||
getProcAddress,
|
||||
|
||||
_gl_context_modes_create,
|
||||
_gl_context_modes_destroy,
|
||||
|
||||
findScreen,
|
||||
windowExists,
|
||||
|
||||
createContext,
|
||||
destroyContext,
|
||||
|
||||
createDrawable,
|
||||
destroyDrawable,
|
||||
getDrawableInfo,
|
||||
|
||||
getUST,
|
||||
NULL, /* glXGetMscRateOML, */
|
||||
|
||||
__glXReportDamage,
|
||||
};
|
||||
|
||||
static const char dri_driver_path[] = DRI_DRIVER_PATH;
|
||||
|
@ -969,7 +785,8 @@ static const char dri_driver_path[] = DRI_DRIVER_PATH;
|
|||
static Bool
|
||||
glxDRIEnterVT (int index, int flags)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(screenInfo.screens[index]);
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
|
||||
|
||||
|
@ -984,7 +801,8 @@ glxDRIEnterVT (int index, int flags)
|
|||
static void
|
||||
glxDRILeaveVT (int index, int flags)
|
||||
{
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
|
||||
__GLXDRIscreen *screen = (__GLXDRIscreen *)
|
||||
glxGetScreen(screenInfo.screens[index]);
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
|
||||
|
||||
|
@ -993,6 +811,48 @@ glxDRILeaveVT (int index, int flags)
|
|||
return (*screen->leaveVT) (index, flags);
|
||||
}
|
||||
|
||||
static void
|
||||
initializeExtensions(__GLXDRIscreen *screen)
|
||||
{
|
||||
const __DRIextension **extensions;
|
||||
int i;
|
||||
|
||||
extensions = screen->driScreen.getExtensions(&screen->driScreen);
|
||||
for (i = 0; extensions[i]; i++) {
|
||||
#ifdef __DRI_COPY_SUB_BUFFER
|
||||
if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
|
||||
screen->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_MESA_copy_sub_buffer");
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_MESA_copy_sub_buffer\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __DRI_SWAP_CONTROL
|
||||
if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
|
||||
screen->swapControl = (__DRIswapControlExtension *) extensions[i];
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_SGI_swap_control");
|
||||
__glXEnableExtension(screen->glx_enable_bits,
|
||||
"GLX_MESA_swap_control");
|
||||
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef __DRI_TEX_OFFSET
|
||||
if (strcmp(extensions[i]->name, __DRI_TEX_OFFSET) == 0) {
|
||||
screen->texOffset = (__DRItexOffsetExtension *) extensions[i];
|
||||
LogMessage(X_INFO, "AIGLX: enabled GLX_texture_from_pixmap with driver support\n");
|
||||
}
|
||||
#endif
|
||||
/* Ignore unknown extensions */
|
||||
}
|
||||
}
|
||||
|
||||
#define COPY_SUB_BUFFER_INTERNAL_VERSION 20060314
|
||||
|
||||
static __GLXscreen *
|
||||
__glXDRIscreenProbe(ScreenPtr pScreen)
|
||||
{
|
||||
|
@ -1013,7 +873,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
char *driverName;
|
||||
drm_handle_t hFB;
|
||||
int junk;
|
||||
__GLcontextModes * driver_modes;
|
||||
__GLXDRIscreen *screen;
|
||||
void *dev_priv = NULL;
|
||||
char filename[128];
|
||||
|
@ -1041,8 +900,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
screen->base.pScreen = pScreen;
|
||||
|
||||
__glXInitExtensionEnableBits(screen->glx_enable_bits);
|
||||
screen->driScreen.screenConfigs = screen;
|
||||
|
||||
|
||||
/* DRI protocol version. */
|
||||
dri_version.major = XF86DRI_MAJOR_VERSION;
|
||||
|
@ -1165,11 +1022,9 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
goto handle_error;
|
||||
}
|
||||
|
||||
driver_modes = NULL;
|
||||
screen->driScreen.private =
|
||||
(*createNewScreen)(NULL, pScreen->myNum,
|
||||
(*createNewScreen)(pScreen->myNum,
|
||||
&screen->driScreen,
|
||||
screen->base.modes,
|
||||
&ddx_version,
|
||||
&dri_version,
|
||||
&drm_version,
|
||||
|
@ -1178,7 +1033,7 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
fd,
|
||||
api_ver,
|
||||
&interface_methods,
|
||||
&driver_modes);
|
||||
&screen->base.fbconfigs);
|
||||
|
||||
if (screen->driScreen.private == NULL) {
|
||||
LogMessage(X_ERROR, "AIGLX error: Calling driver entry point failed");
|
||||
|
@ -1188,6 +1043,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
DRIGetTexOffsetFuncs(pScreen, &screen->texOffsetStart,
|
||||
&screen->texOffsetFinish);
|
||||
|
||||
initializeExtensions(screen);
|
||||
|
||||
__glXScreenInit(&screen->base, pScreen);
|
||||
|
||||
buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
|
||||
|
@ -1201,10 +1058,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
|
|||
screen->base.GLXextensions);
|
||||
}
|
||||
|
||||
|
||||
filter_modes(&screen->base.modes, driver_modes);
|
||||
_gl_context_modes_destroy(driver_modes);
|
||||
|
||||
__glXsetEnterLeaveServerFuncs(__glXDRIenterServer, __glXDRIleaveServer);
|
||||
|
||||
screen->enterVT = pScrn->EnterVT;
|
||||
|
|
254
GL/glx/glxext.c
254
GL/glx/glxext.c
|
@ -45,8 +45,6 @@ __GLXcontext *__glXLastContext;
|
|||
** X resources.
|
||||
*/
|
||||
RESTYPE __glXContextRes;
|
||||
RESTYPE __glXClientRes;
|
||||
RESTYPE __glXPixmapRes;
|
||||
RESTYPE __glXDrawableRes;
|
||||
RESTYPE __glXSwapBarrierRes;
|
||||
|
||||
|
@ -55,11 +53,7 @@ RESTYPE __glXSwapBarrierRes;
|
|||
*/
|
||||
xGLXSingleReply __glXReply;
|
||||
|
||||
/*
|
||||
** A set of state for each client. The 0th one is unused because client
|
||||
** indices start at 1, not 0.
|
||||
*/
|
||||
static __GLXclientState *__glXClients[MAXCLIENTS + 1];
|
||||
static int glxClientPrivateIndex;
|
||||
|
||||
/*
|
||||
** Client that called into GLX dispatch.
|
||||
|
@ -77,29 +71,6 @@ static int __glXDispatch(ClientPtr);
|
|||
static void ResetExtension(ExtensionEntry* extEntry)
|
||||
{
|
||||
__glXFlushContextCache();
|
||||
__glXResetScreens();
|
||||
}
|
||||
|
||||
/*
|
||||
** Initialize the per-client context storage.
|
||||
*/
|
||||
static void ResetClientState(int clientIndex)
|
||||
{
|
||||
__GLXclientState *cl = __glXClients[clientIndex];
|
||||
|
||||
if (cl->returnBuf) xfree(cl->returnBuf);
|
||||
if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
|
||||
if (cl->currentContexts) xfree(cl->currentContexts);
|
||||
memset(cl, 0, sizeof(__GLXclientState));
|
||||
/*
|
||||
** By default, assume that the client supports
|
||||
** GLX major version 1 minor version 0 protocol.
|
||||
*/
|
||||
cl->GLClientmajorVersion = 1;
|
||||
cl->GLClientminorVersion = 0;
|
||||
if (cl->GLClientextensions)
|
||||
xfree(cl->GLClientextensions);
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -129,95 +100,14 @@ static int ContextGone(__GLXcontext* cx, XID id)
|
|||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
** Free a client's state.
|
||||
*/
|
||||
static int ClientGone(int clientIndex, XID id)
|
||||
{
|
||||
__GLXcontext *cx;
|
||||
__GLXclientState *cl = __glXClients[clientIndex];
|
||||
int i;
|
||||
|
||||
if (cl) {
|
||||
/*
|
||||
** Free all the contexts that are current for this client.
|
||||
*/
|
||||
for (i=0; i < cl->numCurrentContexts; i++) {
|
||||
cx = cl->currentContexts[i];
|
||||
if (cx) {
|
||||
__glXDeassociateContext(cx);
|
||||
cx->isCurrent = GL_FALSE;
|
||||
if (!cx->idExists) {
|
||||
__glXFreeContext(cx);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
** Re-initialize the client state structure. Don't free it because
|
||||
** we'll probably get another client with this index and use the struct
|
||||
** again. There is a maximum of MAXCLIENTS of these structures.
|
||||
*/
|
||||
ResetClientState(clientIndex);
|
||||
}
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
** Free a GLX Pixmap.
|
||||
*/
|
||||
static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id)
|
||||
{
|
||||
PixmapPtr pPixmap = (PixmapPtr) pGlxPixmap->pDraw;
|
||||
|
||||
pGlxPixmap->idExists = False;
|
||||
if (!pGlxPixmap->refcnt) {
|
||||
#ifdef XF86DRI
|
||||
if (pGlxPixmap->pDamage) {
|
||||
DamageUnregister (pGlxPixmap->pDraw, pGlxPixmap->pDamage);
|
||||
DamageDestroy(pGlxPixmap->pDamage);
|
||||
}
|
||||
#endif
|
||||
/*
|
||||
** The DestroyPixmap routine should decrement the refcount and free
|
||||
** only if it's zero.
|
||||
*/
|
||||
(*pGlxPixmap->pScreen->DestroyPixmap)(pPixmap);
|
||||
xfree(pGlxPixmap);
|
||||
}
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
/*
|
||||
** Destroy routine that gets called when a drawable is freed. A drawable
|
||||
** contains the ancillary buffers needed for rendering.
|
||||
*/
|
||||
static Bool DrawableGone(__GLXdrawable *glxPriv, XID xid)
|
||||
{
|
||||
__GLXcontext *cx, *cx1;
|
||||
|
||||
/*
|
||||
** Use glxPriv->type to figure out what kind of drawable this is. Don't
|
||||
** use glxPriv->pDraw->type because by the time this routine is called,
|
||||
** the pDraw might already have been freed.
|
||||
*/
|
||||
if (glxPriv->type == DRAWABLE_WINDOW) {
|
||||
/*
|
||||
** When a window is destroyed, notify all context bound to
|
||||
** it, that there are no longer bound to anything.
|
||||
*/
|
||||
for (cx = glxPriv->drawGlxc; cx; cx = cx1) {
|
||||
cx1 = cx->nextDrawPriv;
|
||||
cx->pendingState |= __GLX_PENDING_DESTROY;
|
||||
}
|
||||
|
||||
for (cx = glxPriv->readGlxc; cx; cx = cx1) {
|
||||
cx1 = cx->nextReadPriv;
|
||||
cx->pendingState |= __GLX_PENDING_DESTROY;
|
||||
}
|
||||
}
|
||||
|
||||
glxPriv->pDraw = NULL;
|
||||
glxPriv->drawId = 0;
|
||||
__glXUnrefDrawable(glxPriv);
|
||||
|
||||
return True;
|
||||
|
@ -260,9 +150,10 @@ extern RESTYPE __glXSwapBarrierRes;
|
|||
|
||||
static int SwapBarrierGone(int screen, XID drawable)
|
||||
{
|
||||
if (__glXSwapBarrierFuncs &&
|
||||
__glXSwapBarrierFuncs[screen].bindSwapBarrierFunc != NULL) {
|
||||
__glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, 0);
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
|
||||
|
||||
if (pGlxScreen->swapBarrierFuncs) {
|
||||
pGlxScreen->swapBarrierFuncs->bindSwapBarrierFunc(screen, drawable, 0);
|
||||
}
|
||||
FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE);
|
||||
return True;
|
||||
|
@ -310,22 +201,86 @@ int __glXError(int error)
|
|||
return __glXErrorBase + error;
|
||||
}
|
||||
|
||||
__GLXclientState *
|
||||
glxGetClient(ClientPtr pClient)
|
||||
{
|
||||
return (__GLXclientState *) pClient->devPrivates[glxClientPrivateIndex].ptr;
|
||||
}
|
||||
|
||||
static void
|
||||
glxClientCallback (CallbackListPtr *list,
|
||||
pointer closure,
|
||||
pointer data)
|
||||
{
|
||||
NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
|
||||
ClientPtr pClient = clientinfo->client;
|
||||
__GLXclientState *cl = glxGetClient(pClient);
|
||||
__GLXcontext *cx;
|
||||
int i;
|
||||
|
||||
switch (pClient->clientState) {
|
||||
case ClientStateRunning:
|
||||
/*
|
||||
** By default, assume that the client supports
|
||||
** GLX major version 1 minor version 0 protocol.
|
||||
*/
|
||||
cl->GLClientmajorVersion = 1;
|
||||
cl->GLClientminorVersion = 0;
|
||||
cl->client = pClient;
|
||||
break;
|
||||
|
||||
case ClientStateGone:
|
||||
for (i = 0; i < cl->numCurrentContexts; i++) {
|
||||
cx = cl->currentContexts[i];
|
||||
if (cx) {
|
||||
cx->isCurrent = GL_FALSE;
|
||||
if (!cx->idExists)
|
||||
__glXFreeContext(cx);
|
||||
}
|
||||
}
|
||||
|
||||
if (cl->returnBuf) xfree(cl->returnBuf);
|
||||
if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
|
||||
if (cl->currentContexts) xfree(cl->currentContexts);
|
||||
if (cl->GLClientextensions) xfree(cl->GLClientextensions);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
static __GLXprovider *__glXProviderStack;
|
||||
|
||||
void GlxPushProvider(__GLXprovider *provider)
|
||||
{
|
||||
provider->next = __glXProviderStack;
|
||||
__glXProviderStack = provider;
|
||||
}
|
||||
|
||||
/*
|
||||
** Initialize the GLX extension.
|
||||
*/
|
||||
void GlxExtensionInit(void)
|
||||
{
|
||||
ExtensionEntry *extEntry;
|
||||
ScreenPtr pScreen;
|
||||
int i;
|
||||
__GLXprovider *p;
|
||||
|
||||
__glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
|
||||
__glXClientRes = CreateNewResourceType((DeleteType)ClientGone);
|
||||
__glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
|
||||
__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
|
||||
__glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
|
||||
|
||||
glxClientPrivateIndex = AllocateClientPrivateIndex ();
|
||||
if (!AllocateClientPrivate (glxClientPrivateIndex,
|
||||
sizeof (__GLXclientState)))
|
||||
return;
|
||||
if (!AddCallback (&ClientStateCallback, glxClientCallback, 0))
|
||||
return;
|
||||
|
||||
/*
|
||||
** Add extension to server extensions.
|
||||
*/
|
||||
|
@ -344,17 +299,18 @@ void GlxExtensionInit(void)
|
|||
|
||||
__glXErrorBase = extEntry->errorBase;
|
||||
|
||||
/*
|
||||
** Initialize table of client state. There is never a client 0.
|
||||
*/
|
||||
for (i = 1; i <= MAXCLIENTS; i++) {
|
||||
__glXClients[i] = 0;
|
||||
}
|
||||
for (i = 0; i < screenInfo.numScreens; i++) {
|
||||
pScreen = screenInfo.screens[i];
|
||||
|
||||
/*
|
||||
** Initialize screen specific data.
|
||||
*/
|
||||
__glXInitScreens();
|
||||
for (p = __glXProviderStack; p != NULL; p = p->next) {
|
||||
if (p->screenProbe(pScreen) != NULL) {
|
||||
LogMessage(X_INFO,
|
||||
"GLX: Initialized %s GL provider for screen %d\n",
|
||||
p->name, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/************************************************************************/
|
||||
|
@ -422,11 +378,9 @@ void glxSuspendClients(void)
|
|||
{
|
||||
int i;
|
||||
|
||||
for (i = 1; i <= MAXCLIENTS; i++) {
|
||||
if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
|
||||
continue;
|
||||
|
||||
IgnoreClient(__glXClients[i]->client);
|
||||
for (i = 1; i < currentMaxClients; i++) {
|
||||
if (clients[i] && glxGetClient(clients[i])->inUse)
|
||||
IgnoreClient(clients[i]);
|
||||
}
|
||||
|
||||
glxBlockClients = TRUE;
|
||||
|
@ -439,11 +393,9 @@ void glxResumeClients(void)
|
|||
|
||||
glxBlockClients = FALSE;
|
||||
|
||||
for (i = 1; i <= MAXCLIENTS; i++) {
|
||||
if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
|
||||
continue;
|
||||
|
||||
AttendClient(__glXClients[i]->client);
|
||||
for (i = 1; i < currentMaxClients; i++) {
|
||||
if (clients[i] && glxGetClient(clients[i])->inUse)
|
||||
AttendClient(clients[i]);
|
||||
}
|
||||
|
||||
__glXleaveServer(GL_FALSE);
|
||||
|
@ -505,29 +457,9 @@ static int __glXDispatch(ClientPtr client)
|
|||
int retval;
|
||||
|
||||
opcode = stuff->glxCode;
|
||||
cl = __glXClients[client->index];
|
||||
if (!cl) {
|
||||
cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
|
||||
__glXClients[client->index] = cl;
|
||||
if (!cl) {
|
||||
return BadAlloc;
|
||||
}
|
||||
memset(cl, 0, sizeof(__GLXclientState));
|
||||
}
|
||||
|
||||
if (!cl->inUse) {
|
||||
/*
|
||||
** This is first request from this client. Associate a resource
|
||||
** with the client so we will be notified when the client dies.
|
||||
*/
|
||||
XID xid = FakeClientID(client->index);
|
||||
if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
|
||||
return BadAlloc;
|
||||
}
|
||||
ResetClientState(client->index);
|
||||
cl->inUse = GL_TRUE;
|
||||
cl->client = client;
|
||||
}
|
||||
cl = glxGetClient(client);
|
||||
/* Mark it in use so we suspend it on VT switch. */
|
||||
cl->inUse = TRUE;
|
||||
|
||||
/*
|
||||
** If we're expecting a glXRenderLarge request, this better be one.
|
||||
|
|
|
@ -71,24 +71,6 @@ extern void __glXClearErrorOccured(void);
|
|||
extern GLboolean __glXErrorOccured(void);
|
||||
extern void __glXResetLargeCommandStatus(__GLXclientState*);
|
||||
|
||||
extern int DoMakeCurrent( __GLXclientState *cl, GLXDrawable drawId,
|
||||
GLXDrawable readId, GLXContextID contextId, GLXContextTag tag );
|
||||
extern int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen,
|
||||
GLboolean do_swap);
|
||||
extern int DoGetFBConfigs(__GLXclientState *cl, unsigned screen,
|
||||
GLboolean do_swap);
|
||||
extern int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
|
||||
GLXContextID shareList, VisualID visual, GLuint screen, GLboolean isDirect);
|
||||
extern int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
|
||||
GLuint screenNum, XID pixmapId, XID glxpixmapId, CARD32 *attribs,
|
||||
CARD32 numAttribs);
|
||||
extern int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmapId);
|
||||
|
||||
extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
|
||||
|
||||
extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
|
||||
extern int DoRenderLarge(__GLXclientState *cl, GLbyte *pc, int do_swap);
|
||||
|
||||
extern void GlxExtensionInit(void);
|
||||
|
||||
extern const char GLServerVersion[];
|
||||
|
@ -106,25 +88,5 @@ extern int GlxInitVisuals(
|
|||
int preferredVis
|
||||
);
|
||||
|
||||
typedef struct {
|
||||
void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
|
||||
void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
|
||||
int (* destroyHyperpipeConfigFunc)(int, int);
|
||||
void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
|
||||
} __GLXHyperpipeExtensionFuncs;
|
||||
|
||||
extern void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
|
||||
|
||||
extern __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs;
|
||||
|
||||
typedef struct {
|
||||
int (* bindSwapBarrierFunc)(int, XID, int);
|
||||
int (* queryMaxSwapBarriersFunc)(int);
|
||||
} __GLXSwapBarrierExtensionFuncs;
|
||||
|
||||
extern void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
|
||||
|
||||
extern __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs;
|
||||
|
||||
#endif /* _glxext_h_ */
|
||||
|
||||
|
|
|
@ -70,7 +70,7 @@ struct __GLXMESAdrawable {
|
|||
XMesaBuffer xm_buf;
|
||||
};
|
||||
|
||||
static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid);
|
||||
static XMesaVisual find_mesa_visual(__GLXscreen *screen, XID fbconfigID);
|
||||
|
||||
|
||||
static void
|
||||
|
@ -118,7 +118,7 @@ __glXMesaDrawableSwapBuffers(__GLXdrawable *base)
|
|||
|
||||
static __GLXdrawable *
|
||||
__glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
||||
DrawablePtr pDraw,
|
||||
DrawablePtr pDraw, int type,
|
||||
XID drawId,
|
||||
__GLcontextModes *modes)
|
||||
{
|
||||
|
@ -131,7 +131,8 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
|||
|
||||
memset(glxPriv, 0, sizeof *glxPriv);
|
||||
|
||||
if (!__glXDrawableInit(&glxPriv->base, screen, pDraw, drawId, modes)) {
|
||||
if (!__glXDrawableInit(&glxPriv->base, screen,
|
||||
pDraw, type, drawId, modes)) {
|
||||
xfree(glxPriv);
|
||||
return NULL;
|
||||
}
|
||||
|
@ -140,7 +141,7 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
|||
glxPriv->base.resize = __glXMesaDrawableResize;
|
||||
glxPriv->base.swapBuffers = __glXMesaDrawableSwapBuffers;
|
||||
|
||||
xm_vis = find_mesa_visual(screen, modes->visualID);
|
||||
xm_vis = find_mesa_visual(screen, modes->fbconfigID);
|
||||
if (xm_vis == NULL) {
|
||||
ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
|
||||
modes->visualID);
|
||||
|
@ -154,6 +155,11 @@ __glXMesaScreenCreateDrawable(__GLXscreen *screen,
|
|||
glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0);
|
||||
}
|
||||
|
||||
if (glxPriv->xm_buf == NULL) {
|
||||
xfree(glxPriv);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return &glxPriv->base;
|
||||
}
|
||||
|
||||
|
@ -234,7 +240,7 @@ __glXMesaScreenCreateContext(__GLXscreen *screen,
|
|||
context->base.copy = __glXMesaContextCopy;
|
||||
context->base.forceCurrent = __glXMesaContextForceCurrent;
|
||||
|
||||
xm_vis = find_mesa_visual(screen, modes->visualID);
|
||||
xm_vis = find_mesa_visual(screen, modes->fbconfigID);
|
||||
if (!xm_vis) {
|
||||
ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n",
|
||||
modes->visualID);
|
||||
|
@ -259,7 +265,7 @@ __glXMesaScreenDestroy(__GLXscreen *screen)
|
|||
int i;
|
||||
|
||||
if (mesaScreen->xm_vis) {
|
||||
for (i = 0; i < mesaScreen->num_vis; i++) {
|
||||
for (i = 0; i < mesaScreen->base.numFBConfigs; i++) {
|
||||
if (mesaScreen->xm_vis[i])
|
||||
XMesaDestroyVisual(mesaScreen->xm_vis[i]);
|
||||
}
|
||||
|
@ -273,104 +279,122 @@ __glXMesaScreenDestroy(__GLXscreen *screen)
|
|||
}
|
||||
|
||||
static XMesaVisual
|
||||
find_mesa_visual(__GLXscreen *screen, VisualID vid)
|
||||
find_mesa_visual(__GLXscreen *screen, XID fbconfigID)
|
||||
{
|
||||
__GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen;
|
||||
const __GLcontextModes *modes;
|
||||
unsigned i = 0;
|
||||
|
||||
for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) {
|
||||
if ( modes->visualID == vid ) {
|
||||
break;
|
||||
}
|
||||
|
||||
for (modes = screen->fbconfigs; modes != NULL; modes = modes->next) {
|
||||
if (modes->fbconfigID == fbconfigID)
|
||||
return mesaScreen->xm_vis[i];
|
||||
i++;
|
||||
}
|
||||
|
||||
return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void init_screen_visuals(__GLXMESAscreen *screen)
|
||||
const static int numBack = 2;
|
||||
const static int numDepth = 2;
|
||||
const static int numStencil = 2;
|
||||
|
||||
static __GLcontextModes *
|
||||
createFBConfigsForVisual(__GLXscreen *screen, ScreenPtr pScreen,
|
||||
VisualPtr visual, __GLcontextModes *config)
|
||||
{
|
||||
ScreenPtr pScreen = screen->base.pScreen;
|
||||
__GLcontextModes *modes;
|
||||
XMesaVisual *pXMesaVisual;
|
||||
int *used;
|
||||
int i, j, size;
|
||||
int back, depth, stencil;
|
||||
|
||||
/* Alloc space for the list of XMesa visuals */
|
||||
size = screen->base.numVisuals * sizeof(XMesaVisual);
|
||||
pXMesaVisual = (XMesaVisual *) xalloc(size);
|
||||
memset(pXMesaVisual, 0, size);
|
||||
/* FIXME: Ok, I'm making all this up... anybody has a better idea? */
|
||||
|
||||
/* FIXME: Change 'used' to be a array of bits (rather than of ints),
|
||||
* FIXME: create a stack array of 8 or 16 bytes. If 'numVisuals' is less
|
||||
* FIXME: than 64 or 128 the stack array can be used instead of calling
|
||||
* FIXME: __glXMalloc / __glXFree. If nothing else, convert 'used' to
|
||||
* FIXME: array of bytes instead of ints!
|
||||
*/
|
||||
used = (int *) xalloc(pScreen->numVisuals * sizeof(int));
|
||||
memset(used, 0, pScreen->numVisuals * sizeof(int));
|
||||
for (back = numBack - 1; back >= 0; back--)
|
||||
for (depth = 0; depth < numDepth; depth++)
|
||||
for (stencil = 0; stencil < numStencil; stencil++) {
|
||||
config->visualType = _gl_convert_from_x_visual_type(visual->class);
|
||||
config->xRenderable = GL_TRUE;
|
||||
config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT;
|
||||
config->rgbMode = (visual->class >= TrueColor);
|
||||
config->colorIndexMode = !config->rgbMode;
|
||||
config->renderType =
|
||||
(config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
|
||||
config->doubleBufferMode = back;
|
||||
config->haveDepthBuffer = depth;
|
||||
config->depthBits = depth ? visual->nplanes : 0;
|
||||
config->haveStencilBuffer = stencil;
|
||||
config->stencilBits = stencil ? visual->bitsPerRGBValue : 0;
|
||||
config->haveAccumBuffer = 0;
|
||||
|
||||
config->redBits = Ones(visual->redMask);
|
||||
config->greenBits = Ones(visual->greenMask);
|
||||
config->blueBits = Ones(visual->blueMask);
|
||||
config->alphaBits = 0;
|
||||
config->redMask = visual->redMask;
|
||||
config->greenMask = visual->greenMask;
|
||||
config->blueMask = visual->blueMask;
|
||||
config->alphaMask = 0;
|
||||
config->rgbBits = config->rgbMode ? visual->nplanes : 0;
|
||||
config->indexBits = config->colorIndexMode ? visual->nplanes : 0;
|
||||
config = config->next;
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
static void
|
||||
createFBConfigs(__GLXscreen *pGlxScreen, ScreenPtr pScreen)
|
||||
{
|
||||
__GLcontextModes *configs;
|
||||
int i;
|
||||
|
||||
/* We assume here that each existing visual correspond to a
|
||||
* different visual class. Note, this runs before COMPOSITE adds
|
||||
* its visual, so it's not entirely crazy. */
|
||||
pGlxScreen->numFBConfigs = pScreen->numVisuals * numBack * numDepth * numStencil;
|
||||
pGlxScreen->fbconfigs = _gl_context_modes_create(pGlxScreen->numFBConfigs,
|
||||
sizeof *configs);
|
||||
|
||||
configs = pGlxScreen->fbconfigs;
|
||||
for (i = 0; i < pScreen->numVisuals; i++)
|
||||
configs = createFBConfigsForVisual(pGlxScreen, pScreen,
|
||||
&pScreen->visuals[i], configs);
|
||||
}
|
||||
|
||||
static void
|
||||
createMesaVisuals(__GLXMESAscreen *pMesaScreen)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
ScreenPtr pScreen;
|
||||
VisualPtr visual = NULL;
|
||||
int i, j;
|
||||
|
||||
i = 0;
|
||||
for ( modes = screen->base.modes; modes != NULL; modes = modes->next ) {
|
||||
const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
|
||||
const int nplanes = (modes->rgbBits - modes->alphaBits);
|
||||
const VisualPtr pVis = pScreen->visuals;
|
||||
|
||||
for (j = 0; j < pScreen->numVisuals; j++) {
|
||||
if (pVis[j].class == vis_class &&
|
||||
pVis[j].nplanes == nplanes &&
|
||||
pVis[j].redMask == modes->redMask &&
|
||||
pVis[j].greenMask == modes->greenMask &&
|
||||
pVis[j].blueMask == modes->blueMask &&
|
||||
!used[j]) {
|
||||
|
||||
/* Create the XMesa visual */
|
||||
pXMesaVisual[i] =
|
||||
XMesaCreateVisual(pScreen,
|
||||
&pVis[j],
|
||||
modes->rgbMode,
|
||||
(modes->alphaBits > 0),
|
||||
modes->doubleBufferMode,
|
||||
modes->stereoMode,
|
||||
GL_TRUE, /* ximage_flag */
|
||||
modes->depthBits,
|
||||
modes->stencilBits,
|
||||
modes->accumRedBits,
|
||||
modes->accumGreenBits,
|
||||
modes->accumBlueBits,
|
||||
modes->accumAlphaBits,
|
||||
modes->samples,
|
||||
modes->level,
|
||||
modes->visualRating);
|
||||
/* Set the VisualID */
|
||||
modes->visualID = pVis[j].vid;
|
||||
|
||||
/* Mark this visual used */
|
||||
used[j] = 1;
|
||||
pScreen = pMesaScreen->base.pScreen;
|
||||
pMesaScreen->xm_vis =
|
||||
xcalloc(pMesaScreen->base.numFBConfigs, sizeof (XMesaVisual));
|
||||
for (config = pMesaScreen->base.fbconfigs; config != NULL; config = config->next) {
|
||||
for (j = 0; j < pScreen->numVisuals; j++)
|
||||
if (pScreen->visuals[j].vid == config->visualID) {
|
||||
visual = &pScreen->visuals[j];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ( j == pScreen->numVisuals ) {
|
||||
ErrorF("No matching visual for __GLcontextMode with "
|
||||
"visual class = %d (%d), nplanes = %u\n",
|
||||
vis_class,
|
||||
modes->visualType,
|
||||
(modes->rgbBits - modes->alphaBits) );
|
||||
}
|
||||
else if ( modes->visualID == -1 ) {
|
||||
FatalError( "Matching visual found, but visualID still -1!\n" );
|
||||
}
|
||||
|
||||
i++;
|
||||
pMesaScreen->xm_vis[i++] =
|
||||
XMesaCreateVisual(pScreen,
|
||||
visual,
|
||||
config->rgbMode,
|
||||
(config->alphaBits > 0),
|
||||
config->doubleBufferMode,
|
||||
config->stereoMode,
|
||||
GL_TRUE, /* ximage_flag */
|
||||
config->depthBits,
|
||||
config->stencilBits,
|
||||
config->accumRedBits,
|
||||
config->accumGreenBits,
|
||||
config->accumBlueBits,
|
||||
config->accumAlphaBits,
|
||||
config->samples,
|
||||
config->level,
|
||||
config->visualRating);
|
||||
}
|
||||
|
||||
xfree(used);
|
||||
|
||||
screen->num_vis = pScreen->numVisuals;
|
||||
screen->xm_vis = pXMesaVisual;
|
||||
}
|
||||
|
||||
static __GLXscreen *
|
||||
|
@ -382,19 +406,22 @@ __glXMesaScreenProbe(ScreenPtr pScreen)
|
|||
if (screen == NULL)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Find the GLX visuals that are supported by this screen and create
|
||||
* XMesa's visuals.
|
||||
*/
|
||||
createFBConfigs(&screen->base, pScreen);
|
||||
|
||||
__glXScreenInit(&screen->base, pScreen);
|
||||
|
||||
/* Now that GLX has created the corresponding X visual, create the mesa visuals. */
|
||||
createMesaVisuals(screen);
|
||||
|
||||
screen->base.destroy = __glXMesaScreenDestroy;
|
||||
screen->base.createContext = __glXMesaScreenCreateContext;
|
||||
screen->base.createDrawable = __glXMesaScreenCreateDrawable;
|
||||
screen->base.pScreen = pScreen;
|
||||
|
||||
/*
|
||||
* Find the GLX visuals that are supported by this screen and create
|
||||
* XMesa's visuals.
|
||||
*/
|
||||
init_screen_visuals(screen);
|
||||
|
||||
return &screen->base;
|
||||
}
|
||||
|
||||
|
|
|
@ -40,10 +40,14 @@
|
|||
#include <string.h>
|
||||
#include <windowstr.h>
|
||||
#include <os.h>
|
||||
#include <colormapst.h>
|
||||
|
||||
#include "glxserver.h"
|
||||
#include "glxutil.h"
|
||||
#include "glxext.h"
|
||||
#include "glcontextmodes.h"
|
||||
|
||||
static int glxScreenPrivateIndex;
|
||||
|
||||
const char GLServerVersion[] = "1.4";
|
||||
static const char GLServerExtensions[] =
|
||||
|
@ -179,36 +183,24 @@ static char GLXServerExtensions[] =
|
|||
"GLX_MESA_copy_sub_buffer "
|
||||
;
|
||||
|
||||
__GLXscreen **__glXActiveScreens;
|
||||
|
||||
__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
|
||||
static int __glXNumSwapBarrierFuncs = 0;
|
||||
__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
|
||||
static int __glXNumHyperpipeFuncs = 0;
|
||||
|
||||
__GLXscreen *__glXgetActiveScreen(int num) {
|
||||
return __glXActiveScreens[num];
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** This hook gets called when a window moves or changes size.
|
||||
*/
|
||||
static Bool PositionWindow(WindowPtr pWin, int x, int y)
|
||||
static Bool glxPositionWindow(WindowPtr pWin, int x, int y)
|
||||
{
|
||||
ScreenPtr pScreen;
|
||||
__GLXcontext *glxc;
|
||||
__GLXdrawable *glxPriv;
|
||||
Bool ret;
|
||||
__GLXscreen *pGlxScreen;
|
||||
|
||||
/*
|
||||
** Call wrapped position window routine
|
||||
*/
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
pScreen->PositionWindow =
|
||||
__glXActiveScreens[pScreen->myNum]->WrappedPositionWindow;
|
||||
pGlxScreen = glxGetScreen(pScreen);
|
||||
pScreen->PositionWindow = pGlxScreen->PositionWindow;
|
||||
ret = (*pScreen->PositionWindow)(pWin, x, y);
|
||||
pScreen->PositionWindow = PositionWindow;
|
||||
pScreen->PositionWindow = glxPositionWindow;
|
||||
|
||||
/*
|
||||
** Tell all contexts rendering into this window that the window size
|
||||
|
@ -233,16 +225,6 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y)
|
|||
ret = False;
|
||||
}
|
||||
|
||||
/* mark contexts as needing resize */
|
||||
|
||||
for (glxc = glxPriv->drawGlxc; glxc; glxc = glxc->nextDrawPriv) {
|
||||
glxc->pendingState |= __GLX_PENDING_RESIZE;
|
||||
}
|
||||
|
||||
for (glxc = glxPriv->readGlxc; glxc; glxc = glxc->nextReadPriv) {
|
||||
glxc->pendingState |= __GLX_PENDING_RESIZE;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -259,110 +241,320 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y)
|
|||
|
||||
void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs)
|
||||
{
|
||||
if (__glXNumHyperpipeFuncs < screen + 1) {
|
||||
__glXHyperpipeFuncs = xrealloc(__glXHyperpipeFuncs,
|
||||
(screen+1) * sizeof(__GLXHyperpipeExtensionFuncs));
|
||||
__glXNumHyperpipeFuncs = screen + 1;
|
||||
}
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
|
||||
|
||||
__glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc =
|
||||
*funcs->queryHyperpipeNetworkFunc;
|
||||
__glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc =
|
||||
*funcs->queryHyperpipeConfigFunc;
|
||||
__glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc =
|
||||
*funcs->destroyHyperpipeConfigFunc;
|
||||
__glXHyperpipeFuncs[screen].hyperpipeConfigFunc =
|
||||
*funcs->hyperpipeConfigFunc;
|
||||
pGlxScreen->hyperpipeFuncs = funcs;
|
||||
}
|
||||
|
||||
void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs)
|
||||
{
|
||||
if (__glXNumSwapBarrierFuncs < screen + 1) {
|
||||
__glXSwapBarrierFuncs = xrealloc(__glXSwapBarrierFuncs,
|
||||
(screen+1) * sizeof(__GLXSwapBarrierExtensionFuncs));
|
||||
__glXNumSwapBarrierFuncs = screen + 1;
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
|
||||
|
||||
pGlxScreen->swapBarrierFuncs = funcs;
|
||||
}
|
||||
|
||||
static Bool
|
||||
glxCloseScreen (int index, ScreenPtr pScreen)
|
||||
{
|
||||
__GLXscreen *pGlxScreen = glxGetScreen(pScreen);
|
||||
|
||||
pScreen->CloseScreen = pGlxScreen->CloseScreen;
|
||||
pScreen->PositionWindow = pGlxScreen->PositionWindow;
|
||||
|
||||
pGlxScreen->destroy(pGlxScreen);
|
||||
|
||||
return pScreen->CloseScreen(index, pScreen);
|
||||
}
|
||||
|
||||
__GLXscreen *
|
||||
glxGetScreen(ScreenPtr pScreen)
|
||||
{
|
||||
return (__GLXscreen *) pScreen->devPrivates[glxScreenPrivateIndex].ptr;
|
||||
}
|
||||
|
||||
void GlxSetVisualConfigs(int nconfigs,
|
||||
__GLXvisualConfig *configs, void **privates)
|
||||
{
|
||||
/* We keep this stub around for the DDX drivers that still
|
||||
* call it. */
|
||||
}
|
||||
|
||||
static XID
|
||||
findVisualForConfig(ScreenPtr pScreen, __GLcontextModes *m)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < pScreen->numVisuals; i++) {
|
||||
if (_gl_convert_to_x_visual_type(m->visualType) == pScreen->visuals[i].class)
|
||||
return pScreen->visuals[i].vid;
|
||||
}
|
||||
|
||||
__glXSwapBarrierFuncs[screen].bindSwapBarrierFunc =
|
||||
funcs->bindSwapBarrierFunc;
|
||||
__glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc =
|
||||
funcs->queryMaxSwapBarriersFunc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static __GLXprovider *__glXProviderStack;
|
||||
/* This code inspired by composite/compinit.c. We could move this to
|
||||
* mi/ and share it with composite.*/
|
||||
|
||||
void GlxPushProvider(__GLXprovider *provider)
|
||||
static VisualPtr
|
||||
AddScreenVisuals(ScreenPtr pScreen, int count, int d)
|
||||
{
|
||||
provider->next = __glXProviderStack;
|
||||
__glXProviderStack = provider;
|
||||
XID *installedCmaps, *vids, vid;
|
||||
int numInstalledCmaps, numVisuals, i, j;
|
||||
VisualPtr visuals;
|
||||
ColormapPtr installedCmap;
|
||||
DepthPtr depth;
|
||||
|
||||
depth = NULL;
|
||||
for (i = 0; i < pScreen->numDepths; i++) {
|
||||
if (pScreen->allowedDepths[i].depth == d) {
|
||||
depth = &pScreen->allowedDepths[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (depth == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Find the installed colormaps */
|
||||
installedCmaps = xalloc (pScreen->maxInstalledCmaps * sizeof (XID));
|
||||
if (!installedCmaps)
|
||||
return NULL;
|
||||
|
||||
numInstalledCmaps = pScreen->ListInstalledColormaps(pScreen, installedCmaps);
|
||||
|
||||
/* realloc the visual array to fit the new one in place */
|
||||
numVisuals = pScreen->numVisuals;
|
||||
visuals = xrealloc(pScreen->visuals, (numVisuals + count) * sizeof(VisualRec));
|
||||
if (!visuals) {
|
||||
xfree(installedCmaps);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
vids = xrealloc(depth->vids, (depth->numVids + count) * sizeof(XID));
|
||||
if (vids == NULL) {
|
||||
xfree(installedCmaps);
|
||||
xfree(visuals);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Fix up any existing installed colormaps -- we'll assume that
|
||||
* the only ones created so far have been installed. If this
|
||||
* isn't true, we'll have to walk the resource database looking
|
||||
* for all colormaps.
|
||||
*/
|
||||
for (i = 0; i < numInstalledCmaps; i++) {
|
||||
installedCmap = LookupIDByType (installedCmaps[i], RT_COLORMAP);
|
||||
if (!installedCmap)
|
||||
continue;
|
||||
j = installedCmap->pVisual - pScreen->visuals;
|
||||
installedCmap->pVisual = &visuals[j];
|
||||
}
|
||||
|
||||
xfree(installedCmaps);
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
vid = FakeClientID(0);
|
||||
visuals[pScreen->numVisuals + i].vid = vid;
|
||||
vids[depth->numVids + i] = vid;
|
||||
}
|
||||
|
||||
pScreen->visuals = visuals;
|
||||
pScreen->numVisuals += count;
|
||||
depth->vids = vids;
|
||||
depth->numVids += count;
|
||||
|
||||
/* Return a pointer to the first of the added visuals. */
|
||||
return pScreen->visuals + pScreen->numVisuals - count;
|
||||
}
|
||||
|
||||
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
|
||||
static int
|
||||
findFirstSet(unsigned int v)
|
||||
{
|
||||
screen->pScreen = pScreen;
|
||||
screen->GLextensions = xstrdup(GLServerExtensions);
|
||||
screen->GLXvendor = xstrdup(GLXServerVendorName);
|
||||
screen->GLXversion = xstrdup(GLXServerVersion);
|
||||
screen->GLXextensions = xstrdup(GLXServerExtensions);
|
||||
int i;
|
||||
|
||||
screen->WrappedPositionWindow = pScreen->PositionWindow;
|
||||
pScreen->PositionWindow = PositionWindow;
|
||||
for (i = 0; i < 32; i++)
|
||||
if (v & (1 << i))
|
||||
return i;
|
||||
|
||||
__glXScreenInitVisuals(screen);
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
__glXScreenDestroy(__GLXscreen *screen)
|
||||
static void
|
||||
initGlxVisual(VisualPtr visual, __GLcontextModes *config)
|
||||
{
|
||||
config->visualID = visual->vid;
|
||||
visual->class = _gl_convert_to_x_visual_type(config->visualType);
|
||||
visual->bitsPerRGBValue = config->redBits;
|
||||
visual->ColormapEntries = 1 << config->redBits;
|
||||
visual->nplanes = config->redBits + config->greenBits + config->blueBits;
|
||||
|
||||
visual->redMask = config->redMask;
|
||||
visual->greenMask = config->greenMask;
|
||||
visual->blueMask = config->blueMask;
|
||||
visual->offsetRed = findFirstSet(config->redMask);
|
||||
visual->offsetGreen = findFirstSet(config->greenMask);
|
||||
visual->offsetBlue = findFirstSet(config->blueMask);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
GLboolean doubleBuffer;
|
||||
GLboolean depthBuffer;
|
||||
} FBConfigTemplateRec, *FBConfigTemplatePtr;
|
||||
|
||||
static __GLcontextModes *
|
||||
pickFBConfig(__GLXscreen *pGlxScreen, FBConfigTemplatePtr template, int class)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
|
||||
for (config = pGlxScreen->fbconfigs; config != NULL; config = config->next) {
|
||||
if (config->visualRating != GLX_NONE)
|
||||
continue;
|
||||
if (_gl_convert_to_x_visual_type(config->visualType) != class)
|
||||
continue;
|
||||
if ((config->doubleBufferMode > 0) != template->doubleBuffer)
|
||||
continue;
|
||||
if ((config->depthBits > 0) != template->depthBuffer)
|
||||
continue;
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
addMinimalSet(__GLXscreen *pGlxScreen)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
VisualPtr visuals;
|
||||
int i;
|
||||
FBConfigTemplateRec best = { GL_TRUE, GL_TRUE };
|
||||
FBConfigTemplateRec minimal = { GL_FALSE, GL_FALSE };
|
||||
|
||||
pGlxScreen->visuals = xcalloc(pGlxScreen->pScreen->numVisuals,
|
||||
sizeof (__GLcontextModes *));
|
||||
if (pGlxScreen->visuals == NULL) {
|
||||
ErrorF("Failed to allocate for minimal set of GLX visuals\n");
|
||||
return;
|
||||
}
|
||||
|
||||
pGlxScreen->numVisuals = pGlxScreen->pScreen->numVisuals;
|
||||
visuals = pGlxScreen->pScreen->visuals;
|
||||
for (i = 0; i < pGlxScreen->numVisuals; i++) {
|
||||
if (visuals[i].nplanes == 32)
|
||||
config = pickFBConfig(pGlxScreen, &minimal, visuals[i].class);
|
||||
else
|
||||
config = pickFBConfig(pGlxScreen, &best, visuals[i].class);
|
||||
if (config == NULL)
|
||||
config = pGlxScreen->fbconfigs;
|
||||
pGlxScreen->visuals[i] = config;
|
||||
config->visualID = visuals[i].vid;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
addTypicalSet(__GLXscreen *pGlxScreen)
|
||||
{
|
||||
addMinimalSet(pGlxScreen);
|
||||
}
|
||||
|
||||
static void
|
||||
addFullSet(__GLXscreen *pGlxScreen)
|
||||
{
|
||||
__GLcontextModes *config;
|
||||
VisualPtr visuals;
|
||||
int i, depth;
|
||||
|
||||
pGlxScreen->visuals =
|
||||
xcalloc(pGlxScreen->numFBConfigs, sizeof (__GLcontextModes *));
|
||||
if (pGlxScreen->visuals == NULL) {
|
||||
ErrorF("Failed to allocate for full set of GLX visuals\n");
|
||||
return;
|
||||
}
|
||||
|
||||
config = pGlxScreen->fbconfigs;
|
||||
depth = config->redBits + config->greenBits + config->blueBits;
|
||||
visuals = AddScreenVisuals(pGlxScreen->pScreen, pGlxScreen->numFBConfigs, depth);
|
||||
if (visuals == NULL) {
|
||||
xfree(pGlxScreen->visuals);
|
||||
return;
|
||||
}
|
||||
|
||||
pGlxScreen->numVisuals = pGlxScreen->numFBConfigs;
|
||||
for (i = 0, config = pGlxScreen->fbconfigs; config; config = config->next, i++) {
|
||||
pGlxScreen->visuals[i] = config;
|
||||
initGlxVisual(&visuals[i], config);
|
||||
}
|
||||
}
|
||||
|
||||
static int glxVisualConfig = GLX_ALL_VISUALS;
|
||||
|
||||
void GlxSetVisualConfig(int config)
|
||||
{
|
||||
glxVisualConfig = config;
|
||||
}
|
||||
|
||||
void __glXScreenInit(__GLXscreen *pGlxScreen, ScreenPtr pScreen)
|
||||
{
|
||||
static int glxGeneration;
|
||||
__GLcontextModes *m;
|
||||
int i;
|
||||
|
||||
if (glxGeneration != serverGeneration)
|
||||
{
|
||||
glxScreenPrivateIndex = AllocateScreenPrivateIndex ();
|
||||
if (glxScreenPrivateIndex == -1)
|
||||
return;
|
||||
|
||||
glxGeneration = serverGeneration;
|
||||
}
|
||||
|
||||
pGlxScreen->pScreen = pScreen;
|
||||
pGlxScreen->GLextensions = xstrdup(GLServerExtensions);
|
||||
pGlxScreen->GLXvendor = xstrdup(GLXServerVendorName);
|
||||
pGlxScreen->GLXversion = xstrdup(GLXServerVersion);
|
||||
pGlxScreen->GLXextensions = xstrdup(GLXServerExtensions);
|
||||
|
||||
pGlxScreen->PositionWindow = pScreen->PositionWindow;
|
||||
pScreen->PositionWindow = glxPositionWindow;
|
||||
|
||||
pGlxScreen->CloseScreen = pScreen->CloseScreen;
|
||||
pScreen->CloseScreen = glxCloseScreen;
|
||||
|
||||
i = 0;
|
||||
for (m = pGlxScreen->fbconfigs; m != NULL; m = m->next) {
|
||||
m->fbconfigID = FakeClientID(0);
|
||||
m->visualID = findVisualForConfig(pScreen, m);
|
||||
i++;
|
||||
}
|
||||
pGlxScreen->numFBConfigs = i;
|
||||
|
||||
/* Select a subset of fbconfigs that we send to the client when it
|
||||
* asks for the glx visuals. All the fbconfigs here have a valid
|
||||
* value for visual ID and each visual ID is only present once.
|
||||
* This runs before composite adds its extra visual so we have to
|
||||
* remember the number of visuals here.*/
|
||||
|
||||
switch (glxVisualConfig) {
|
||||
case GLX_MINIMAL_VISUALS:
|
||||
addMinimalSet(pGlxScreen);
|
||||
break;
|
||||
case GLX_TYPICAL_VISUALS:
|
||||
addTypicalSet(pGlxScreen);
|
||||
break;
|
||||
case GLX_ALL_VISUALS:
|
||||
addFullSet(pGlxScreen);
|
||||
break;
|
||||
}
|
||||
|
||||
pScreen->devPrivates[glxScreenPrivateIndex].ptr = (pointer) pGlxScreen;
|
||||
}
|
||||
|
||||
void __glXScreenDestroy(__GLXscreen *screen)
|
||||
{
|
||||
xfree(screen->GLXvendor);
|
||||
xfree(screen->GLXversion);
|
||||
xfree(screen->GLXextensions);
|
||||
xfree(screen->GLextensions);
|
||||
}
|
||||
|
||||
void __glXInitScreens(void)
|
||||
{
|
||||
GLint i;
|
||||
ScreenPtr pScreen;
|
||||
__GLXprovider *p;
|
||||
size_t size;
|
||||
|
||||
/*
|
||||
** This alloc has to work or else the server might as well core dump.
|
||||
*/
|
||||
size = screenInfo.numScreens * sizeof(__GLXscreen *);
|
||||
__glXActiveScreens = xalloc(size);
|
||||
memset(__glXActiveScreens, 0, size);
|
||||
|
||||
for (i = 0; i < screenInfo.numScreens; i++) {
|
||||
pScreen = screenInfo.screens[i];
|
||||
|
||||
for (p = __glXProviderStack; p != NULL; p = p->next) {
|
||||
__glXActiveScreens[i] = p->screenProbe(pScreen);
|
||||
if (__glXActiveScreens[i] != NULL) {
|
||||
LogMessage(X_INFO,
|
||||
"GLX: Initialized %s GL provider for screen %d\n",
|
||||
p->name, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void __glXResetScreens(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < screenInfo.numScreens; i++)
|
||||
if (__glXActiveScreens[i])
|
||||
__glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
|
||||
|
||||
xfree(__glXActiveScreens);
|
||||
xfree(__glXHyperpipeFuncs);
|
||||
xfree(__glXSwapBarrierFuncs);
|
||||
__glXNumHyperpipeFuncs = 0;
|
||||
__glXNumSwapBarrierFuncs = 0;
|
||||
__glXHyperpipeFuncs = NULL;
|
||||
__glXSwapBarrierFuncs = NULL;
|
||||
__glXActiveScreens = NULL;
|
||||
}
|
||||
|
|
|
@ -42,6 +42,21 @@
|
|||
|
||||
#include "GL/internal/glcore.h"
|
||||
|
||||
typedef struct {
|
||||
void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
|
||||
void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
|
||||
int (* destroyHyperpipeConfigFunc)(int, int);
|
||||
void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
|
||||
} __GLXHyperpipeExtensionFuncs;
|
||||
|
||||
typedef struct {
|
||||
int (* bindSwapBarrierFunc)(int, XID, int);
|
||||
int (* queryMaxSwapBarriersFunc)(int);
|
||||
} __GLXSwapBarrierExtensionFuncs;
|
||||
|
||||
void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
|
||||
void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
|
||||
|
||||
/*
|
||||
** Screen dependent data. These methods are the interface between the DIX
|
||||
** and DDX layers of the GLX server extension. The methods provide an
|
||||
|
@ -57,21 +72,24 @@ struct __GLXscreen {
|
|||
|
||||
__GLXdrawable *(*createDrawable)(__GLXscreen *context,
|
||||
DrawablePtr pDraw,
|
||||
int type,
|
||||
XID drawId,
|
||||
__GLcontextModes *modes);
|
||||
int (*swapInterval) (__GLXdrawable *drawable,
|
||||
int interval);
|
||||
|
||||
__GLXHyperpipeExtensionFuncs *hyperpipeFuncs;
|
||||
__GLXSwapBarrierExtensionFuncs *swapBarrierFuncs;
|
||||
|
||||
ScreenPtr pScreen;
|
||||
|
||||
/**
|
||||
* Linked list of valid context modes for this screen.
|
||||
*/
|
||||
__GLcontextModes *modes;
|
||||
/* Linked list of valid fbconfigs for this screen. */
|
||||
__GLcontextModes *fbconfigs;
|
||||
int numFBConfigs;
|
||||
|
||||
void **pVisualPriv;
|
||||
/* Subset of fbconfigs that are exposed as GLX visuals. */
|
||||
__GLcontextModes **visuals;
|
||||
GLint numVisuals;
|
||||
GLint numUsableVisuals;
|
||||
|
||||
char *GLextensions;
|
||||
|
||||
|
@ -79,18 +97,12 @@ struct __GLXscreen {
|
|||
char *GLXversion;
|
||||
char *GLXextensions;
|
||||
|
||||
/*
|
||||
** Things that are not statically set.
|
||||
*/
|
||||
Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y);
|
||||
|
||||
Bool (*PositionWindow)(WindowPtr pWin, int x, int y);
|
||||
Bool (*CloseScreen)(int index, ScreenPtr pScreen);
|
||||
};
|
||||
|
||||
|
||||
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen);
|
||||
void __glXScreenDestroy(__GLXscreen *screen);
|
||||
|
||||
void __glXInitScreens(void);
|
||||
extern void __glXResetScreens(void);
|
||||
|
||||
#endif /* !__GLX_screens_h__ */
|
||||
|
|
|
@ -90,12 +90,13 @@ typedef XID GLXDrawable;
|
|||
|
||||
typedef struct __GLXclientStateRec __GLXclientState;
|
||||
|
||||
extern __GLXscreen **__glXActiveScreens;
|
||||
extern GLint __glXNumActiveScreens;
|
||||
extern __GLXscreen *__glXgetActiveScreen(int num);
|
||||
extern __GLXscreen *glxGetScreen(ScreenPtr pScreen);
|
||||
extern __GLXclientState *glxGetClient(ClientPtr pClient);
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
void GlxExtensionInit(void);
|
||||
|
||||
void GlxSetVisualConfigs(int nconfigs,
|
||||
__GLXvisualConfig *configs, void **privates);
|
||||
|
||||
|
@ -133,6 +134,14 @@ struct __GLXprovider {
|
|||
|
||||
void GlxPushProvider(__GLXprovider *provider);
|
||||
|
||||
enum {
|
||||
GLX_MINIMAL_VISUALS,
|
||||
GLX_TYPICAL_VISUALS,
|
||||
GLX_ALL_VISUALS
|
||||
};
|
||||
|
||||
void GlxSetVisualConfig(int config);
|
||||
|
||||
void __glXsetEnterLeaveServerFuncs(void (*enter)(GLboolean),
|
||||
void (*leave)(GLboolean));
|
||||
void __glXenterServer(GLboolean rendering);
|
||||
|
|
|
@ -139,18 +139,15 @@ __glXUnrefDrawable(__GLXdrawable *glxPriv)
|
|||
|
||||
GLboolean
|
||||
__glXDrawableInit(__GLXdrawable *drawable,
|
||||
__GLXscreen *screen, DrawablePtr pDraw, XID drawId,
|
||||
__GLcontextModes *modes)
|
||||
__GLXscreen *screen, DrawablePtr pDraw, int type,
|
||||
XID drawId, __GLcontextModes *modes)
|
||||
{
|
||||
drawable->type = pDraw->type;
|
||||
drawable->pDraw = pDraw;
|
||||
drawable->type = type;
|
||||
drawable->drawId = drawId;
|
||||
drawable->refCount = 1;
|
||||
drawable->modes = modes;
|
||||
|
||||
/* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */
|
||||
drawable->pGlxPixmap = (__GLXpixmap *)
|
||||
LookupIDByType(drawId, __glXPixmapRes);
|
||||
drawable->eventMask = 0;
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
|
|
@ -50,7 +50,7 @@ extern void __glXUnrefDrawable(__GLXdrawable *glxPriv);
|
|||
|
||||
extern GLboolean __glXDrawableInit(__GLXdrawable *drawable,
|
||||
__GLXscreen *screen,
|
||||
DrawablePtr pDraw, XID drawID,
|
||||
DrawablePtr pDraw, int type, XID drawID,
|
||||
__GLcontextModes *modes);
|
||||
|
||||
/* context helper routines */
|
||||
|
|
|
@ -1,518 +0,0 @@
|
|||
/*
|
||||
* Copyright © 2006 Red Hat, Inc.
|
||||
* (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* 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
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sub license,
|
||||
* 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, INC, OR PRECISION INSIGHT 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 <kevin@precisioninsight.com>
|
||||
* Brian Paul <brian@precisioninsight.com>
|
||||
* Kristian Høgsberg <krh@redhat.com>
|
||||
*
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <regionstr.h>
|
||||
#include <resource.h>
|
||||
#include <GL/gl.h>
|
||||
#include <GL/glxint.h>
|
||||
#include <GL/glxtokens.h>
|
||||
#include <GL/internal/glcore.h>
|
||||
#include <scrnintstr.h>
|
||||
#include <config.h>
|
||||
#include <glxserver.h>
|
||||
#include <glxscreens.h>
|
||||
#include <glxdrawable.h>
|
||||
#include <glxcontext.h>
|
||||
#include <glxext.h>
|
||||
#include <glxutil.h>
|
||||
#include <micmap.h>
|
||||
|
||||
void GlxWrapInitVisuals(miInitVisualsProcPtr *);
|
||||
|
||||
#include "glcontextmodes.h"
|
||||
|
||||
struct ScreenVisualsRec {
|
||||
int num_vis;
|
||||
void *private;
|
||||
__GLcontextModes *modes;
|
||||
};
|
||||
typedef struct ScreenVisualsRec ScreenVisuals;
|
||||
|
||||
static ScreenVisuals screenVisuals[MAXSCREENS];
|
||||
|
||||
static int numConfigs = 0;
|
||||
static __GLXvisualConfig *visualConfigs = NULL;
|
||||
static void **visualPrivates = NULL;
|
||||
|
||||
static int count_bits(unsigned int n)
|
||||
{
|
||||
int bits = 0;
|
||||
|
||||
while (n > 0) {
|
||||
if (n & 1) bits++;
|
||||
n >>= 1;
|
||||
}
|
||||
return bits;
|
||||
}
|
||||
|
||||
/*
|
||||
* In the case the driver defines no GLX visuals we'll use these.
|
||||
* Note that for TrueColor and DirectColor visuals, bufferSize is the
|
||||
* sum of redSize, greenSize, blueSize and alphaSize, which may be larger
|
||||
* than the nplanes/rootDepth of the server's X11 visuals
|
||||
*/
|
||||
#define NUM_FALLBACK_CONFIGS 5
|
||||
static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
|
||||
/* [0] = RGB, double buffered, Z */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 0, /* rgba sizes */
|
||||
-1, -1, -1, 0, /* rgba masks */
|
||||
0, 0, 0, 0, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
0, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [1] = RGB, double buffered, Z, stencil, accum */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 0, /* rgba sizes */
|
||||
-1, -1, -1, 0, /* rgba masks */
|
||||
16, 16, 16, 0, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
8, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [2] = RGB+Alpha, double buffered, Z, stencil, accum */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 8, /* rgba sizes */
|
||||
-1, -1, -1, -1, /* rgba masks */
|
||||
16, 16, 16, 16, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
8, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [3] = RGB+Alpha, single buffered, Z, stencil, accum */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
True, /* rgba */
|
||||
-1, -1, -1, 8, /* rgba sizes */
|
||||
-1, -1, -1, -1, /* rgba masks */
|
||||
16, 16, 16, 16, /* rgba accum sizes */
|
||||
False, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
8, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
/* [4] = CI, double buffered, Z */
|
||||
{
|
||||
-1, /* vid */
|
||||
-1, /* class */
|
||||
False, /* rgba? (false = color index) */
|
||||
-1, -1, -1, 0, /* rgba sizes */
|
||||
-1, -1, -1, 0, /* rgba masks */
|
||||
0, 0, 0, 0, /* rgba accum sizes */
|
||||
True, /* doubleBuffer */
|
||||
False, /* stereo */
|
||||
-1, /* bufferSize */
|
||||
16, /* depthSize */
|
||||
0, /* stencilSize */
|
||||
0, /* auxBuffers */
|
||||
0, /* level */
|
||||
GLX_NONE, /* visualRating */
|
||||
GLX_NONE, /* transparentPixel */
|
||||
0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */
|
||||
0 /* transparentIndex */
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
|
||||
VisualID *defaultVisp,
|
||||
int ndepth, DepthPtr pdepth,
|
||||
int rootDepth)
|
||||
{
|
||||
int numRGBconfigs;
|
||||
int numCIconfigs;
|
||||
int numVisuals = *nvisualp;
|
||||
int numNewVisuals;
|
||||
int numNewConfigs;
|
||||
VisualPtr pVisual = *visualp;
|
||||
VisualPtr pVisualNew = NULL;
|
||||
VisualID *orig_vid = NULL;
|
||||
__GLcontextModes *modes;
|
||||
__GLXvisualConfig *pNewVisualConfigs = NULL;
|
||||
void **glXVisualPriv;
|
||||
void **pNewVisualPriv;
|
||||
int found_default;
|
||||
int i, j, k;
|
||||
|
||||
if (numConfigs > 0)
|
||||
numNewConfigs = numConfigs;
|
||||
else
|
||||
numNewConfigs = NUM_FALLBACK_CONFIGS;
|
||||
|
||||
/* Alloc space for the list of new GLX visuals */
|
||||
pNewVisualConfigs = (__GLXvisualConfig *)
|
||||
xalloc(numNewConfigs * sizeof(__GLXvisualConfig));
|
||||
if (!pNewVisualConfigs) {
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the list of new GLX visual privates */
|
||||
pNewVisualPriv = (void **) xalloc(numNewConfigs * sizeof(void *));
|
||||
if (!pNewVisualPriv) {
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
** If SetVisualConfigs was not called, then use default GLX
|
||||
** visual configs.
|
||||
*/
|
||||
if (numConfigs == 0) {
|
||||
memcpy(pNewVisualConfigs, FallbackConfigs,
|
||||
NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
|
||||
memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
|
||||
}
|
||||
else {
|
||||
/* copy driver's visual config info */
|
||||
for (i = 0; i < numConfigs; i++) {
|
||||
pNewVisualConfigs[i] = visualConfigs[i];
|
||||
pNewVisualPriv[i] = visualPrivates[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* Count the number of RGB and CI visual configs */
|
||||
numRGBconfigs = 0;
|
||||
numCIconfigs = 0;
|
||||
for (i = 0; i < numNewConfigs; i++) {
|
||||
if (pNewVisualConfigs[i].rgba)
|
||||
numRGBconfigs++;
|
||||
else
|
||||
numCIconfigs++;
|
||||
}
|
||||
|
||||
/* Count the total number of visuals to compute */
|
||||
numNewVisuals = 0;
|
||||
for (i = 0; i < numVisuals; i++) {
|
||||
numNewVisuals +=
|
||||
(pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
|
||||
? numRGBconfigs : numCIconfigs;
|
||||
}
|
||||
|
||||
/* Reset variables for use with the next screen/driver's visual configs */
|
||||
visualConfigs = NULL;
|
||||
numConfigs = 0;
|
||||
|
||||
/* Alloc temp space for the list of orig VisualIDs for each new visual */
|
||||
orig_vid = (VisualID *) xalloc(numNewVisuals * sizeof(VisualID));
|
||||
if (!orig_vid) {
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the list of glXVisuals */
|
||||
modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes));
|
||||
if (modes == NULL) {
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the list of glXVisualPrivates */
|
||||
glXVisualPriv = (void **)xalloc(numNewVisuals * sizeof(void *));
|
||||
if (!glXVisualPriv) {
|
||||
_gl_context_modes_destroy( modes );
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Alloc space for the new list of the X server's visuals */
|
||||
pVisualNew = (VisualPtr)xalloc(numNewVisuals * sizeof(VisualRec));
|
||||
if (!pVisualNew) {
|
||||
xfree(glXVisualPriv);
|
||||
_gl_context_modes_destroy( modes );
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/* Initialize the new visuals */
|
||||
found_default = FALSE;
|
||||
screenVisuals[screenInfo.numScreens-1].modes = modes;
|
||||
for (i = j = 0; i < numVisuals; i++) {
|
||||
int is_rgb = (pVisual[i].class == TrueColor ||
|
||||
pVisual[i].class == DirectColor);
|
||||
|
||||
for (k = 0; k < numNewConfigs; k++) {
|
||||
if (pNewVisualConfigs[k].rgba != is_rgb)
|
||||
continue;
|
||||
|
||||
assert( modes != NULL );
|
||||
|
||||
/* Initialize the new visual */
|
||||
pVisualNew[j] = pVisual[i];
|
||||
pVisualNew[j].vid = FakeClientID(0);
|
||||
|
||||
/* Check for the default visual */
|
||||
if (!found_default && pVisual[i].vid == *defaultVisp) {
|
||||
*defaultVisp = pVisualNew[j].vid;
|
||||
found_default = TRUE;
|
||||
}
|
||||
|
||||
/* Save the old VisualID */
|
||||
orig_vid[j] = pVisual[i].vid;
|
||||
|
||||
/* Initialize the glXVisual */
|
||||
_gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] );
|
||||
modes->visualID = pVisualNew[j].vid;
|
||||
if (modes->fbconfigID == GLX_DONT_CARE)
|
||||
modes->fbconfigID = modes->visualID;
|
||||
|
||||
/*
|
||||
* If the class is -1, then assume the X visual information
|
||||
* is identical to what GLX needs, and take them from the X
|
||||
* visual. NOTE: if class != -1, then all other fields MUST
|
||||
* be initialized.
|
||||
*/
|
||||
if (modes->visualType == GLX_NONE) {
|
||||
modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class );
|
||||
modes->redBits = count_bits(pVisual[i].redMask);
|
||||
modes->greenBits = count_bits(pVisual[i].greenMask);
|
||||
modes->blueBits = count_bits(pVisual[i].blueMask);
|
||||
modes->alphaBits = modes->alphaBits;
|
||||
modes->redMask = pVisual[i].redMask;
|
||||
modes->greenMask = pVisual[i].greenMask;
|
||||
modes->blueMask = pVisual[i].blueMask;
|
||||
modes->alphaMask = modes->alphaMask;
|
||||
modes->rgbBits = (is_rgb)
|
||||
? (modes->redBits + modes->greenBits +
|
||||
modes->blueBits + modes->alphaBits)
|
||||
: rootDepth;
|
||||
}
|
||||
|
||||
/* Save the device-dependent private for this visual */
|
||||
glXVisualPriv[j] = pNewVisualPriv[k];
|
||||
|
||||
j++;
|
||||
modes = modes->next;
|
||||
}
|
||||
}
|
||||
|
||||
assert(j <= numNewVisuals);
|
||||
|
||||
/* Save the GLX visuals in the screen structure */
|
||||
screenVisuals[screenInfo.numScreens-1].num_vis = numNewVisuals;
|
||||
screenVisuals[screenInfo.numScreens-1].private = glXVisualPriv;
|
||||
|
||||
/* Set up depth's VisualIDs */
|
||||
for (i = 0; i < ndepth; i++) {
|
||||
int numVids = 0;
|
||||
VisualID *pVids = NULL;
|
||||
int k, n = 0;
|
||||
|
||||
/* Count the new number of VisualIDs at this depth */
|
||||
for (j = 0; j < pdepth[i].numVids; j++)
|
||||
for (k = 0; k < numNewVisuals; k++)
|
||||
if (pdepth[i].vids[j] == orig_vid[k])
|
||||
numVids++;
|
||||
|
||||
/* Allocate a new list of VisualIDs for this depth */
|
||||
pVids = (VisualID *)xalloc(numVids * sizeof(VisualID));
|
||||
|
||||
/* Initialize the new list of VisualIDs for this depth */
|
||||
for (j = 0; j < pdepth[i].numVids; j++)
|
||||
for (k = 0; k < numNewVisuals; k++)
|
||||
if (pdepth[i].vids[j] == orig_vid[k])
|
||||
pVids[n++] = pVisualNew[k].vid;
|
||||
|
||||
/* Update this depth's list of VisualIDs */
|
||||
xfree(pdepth[i].vids);
|
||||
pdepth[i].vids = pVids;
|
||||
pdepth[i].numVids = numVids;
|
||||
}
|
||||
|
||||
/* Update the X server's visuals */
|
||||
*nvisualp = numNewVisuals;
|
||||
*visualp = pVisualNew;
|
||||
|
||||
/* Free the old list of the X server's visuals */
|
||||
xfree(pVisual);
|
||||
|
||||
/* Clean up temporary allocations */
|
||||
xfree(orig_vid);
|
||||
xfree(pNewVisualPriv);
|
||||
xfree(pNewVisualConfigs);
|
||||
|
||||
/* Free the private list created by DDX HW driver */
|
||||
if (visualPrivates)
|
||||
xfree(visualPrivates);
|
||||
visualPrivates = NULL;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void GlxSetVisualConfigs(int nconfigs,
|
||||
__GLXvisualConfig *configs, void **privates)
|
||||
{
|
||||
numConfigs = nconfigs;
|
||||
visualConfigs = configs;
|
||||
visualPrivates = privates;
|
||||
}
|
||||
|
||||
static miInitVisualsProcPtr saveInitVisualsProc;
|
||||
|
||||
Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
|
||||
int *nvisualp, int *ndepthp,
|
||||
int *rootDepthp, VisualID *defaultVisp,
|
||||
unsigned long sizes, int bitsPerRGB,
|
||||
int preferredVis)
|
||||
{
|
||||
Bool ret;
|
||||
|
||||
if (saveInitVisualsProc) {
|
||||
ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
|
||||
rootDepthp, defaultVisp, sizes, bitsPerRGB,
|
||||
preferredVis);
|
||||
if (!ret)
|
||||
return False;
|
||||
}
|
||||
|
||||
/*
|
||||
* Setup the visuals supported by this particular screen.
|
||||
*/
|
||||
init_visuals(nvisualp, visualp, defaultVisp,
|
||||
*ndepthp, *depthp, *rootDepthp);
|
||||
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
|
||||
/************************************************************************/
|
||||
|
||||
|
||||
void
|
||||
GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
|
||||
{
|
||||
saveInitVisualsProc = *initVisProc;
|
||||
*initVisProc = GlxInitVisuals;
|
||||
}
|
||||
|
||||
static void fixup_visuals(int screen)
|
||||
{
|
||||
ScreenPtr pScreen = screenInfo.screens[screen];
|
||||
ScreenVisuals *psv = &screenVisuals[screen];
|
||||
int j;
|
||||
__GLcontextModes *modes;
|
||||
|
||||
for ( modes = psv->modes ; modes != NULL ; modes = modes->next ) {
|
||||
const int vis_class = _gl_convert_to_x_visual_type( modes->visualType );
|
||||
const int nplanes = (modes->rgbBits - modes->alphaBits);
|
||||
const VisualPtr pVis = pScreen->visuals;
|
||||
|
||||
/* Find a visual that matches the GLX visual's class and size */
|
||||
for (j = 0; j < pScreen->numVisuals; j++) {
|
||||
if (pVis[j].class == vis_class &&
|
||||
pVis[j].nplanes == nplanes) {
|
||||
|
||||
/* Fixup the masks */
|
||||
modes->redMask = pVis[j].redMask;
|
||||
modes->greenMask = pVis[j].greenMask;
|
||||
modes->blueMask = pVis[j].blueMask;
|
||||
|
||||
/* Recalc the sizes */
|
||||
modes->redBits = count_bits(modes->redMask);
|
||||
modes->greenBits = count_bits(modes->greenMask);
|
||||
modes->blueBits = count_bits(modes->blueMask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void __glXScreenInitVisuals(__GLXscreen *screen)
|
||||
{
|
||||
int index = screen->pScreen->myNum;
|
||||
|
||||
screen->modes = screenVisuals[index].modes;
|
||||
screen->pVisualPriv = screenVisuals[index].private;
|
||||
screen->numVisuals = screenVisuals[index].num_vis;
|
||||
screen->numUsableVisuals = screenVisuals[index].num_vis;
|
||||
|
||||
/*
|
||||
* The ordering of the rgb compenents might have been changed by the
|
||||
* driver after mi initialized them.
|
||||
*/
|
||||
fixup_visuals(index);
|
||||
}
|
|
@ -207,6 +207,8 @@ extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
|
||||
|
@ -293,8 +295,8 @@ extern HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -371,14 +373,16 @@ extern HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
|
||||
|
@ -619,8 +623,8 @@ extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
|||
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
|
||||
|
@ -669,6 +673,8 @@ extern HIDDEN void __glXDisp_Lighti(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
|
||||
extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
|
||||
extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
|
||||
|
@ -751,8 +757,8 @@ extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
|
|||
extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
|
||||
extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
|
||||
|
|
|
@ -697,6 +697,7 @@ __glGetBooleanv_size(GLenum e)
|
|||
case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
|
||||
case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
|
||||
case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
|
||||
case GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:
|
||||
case GL_POINT_SPRITE_ARB:
|
||||
/* case GL_POINT_SPRITE_NV:*/
|
||||
case GL_POINT_SPRITE_R_MODE_NV:
|
||||
|
@ -704,8 +705,11 @@ __glGetBooleanv_size(GLenum e)
|
|||
case GL_MAX_TEXTURE_COORDS_ARB:
|
||||
case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
|
||||
case GL_DEPTH_BOUNDS_TEST_EXT:
|
||||
case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:
|
||||
case GL_STENCIL_TEST_TWO_SIDE_EXT:
|
||||
case GL_ACTIVE_STENCIL_FACE_EXT:
|
||||
case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
|
||||
case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
|
||||
case GL_RASTER_POSITION_UNCLIPPED_IBM:
|
||||
return 1;
|
||||
case GL_SMOOTH_POINT_SIZE_RANGE:
|
||||
|
|
|
@ -1575,9 +1575,9 @@ static const void *VendorPriv_function_table[104][2] = {
|
|||
/* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
|
||||
/* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
|
||||
/* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
|
||||
/* [ 95] = 65543 */ {NULL, NULL},
|
||||
/* [ 96] = 65544 */ {NULL, NULL},
|
||||
/* [ 97] = 65545 */ {NULL, NULL},
|
||||
/* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},
|
||||
/* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},
|
||||
/* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},
|
||||
/* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},
|
||||
/* [ 99] = 65547 */ {NULL, NULL},
|
||||
/* [ 100] = 65548 */ {NULL, NULL},
|
||||
|
|
|
@ -2033,7 +2033,7 @@ static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
|
|||
}
|
||||
nmasks = creq->planes;
|
||||
length = ((long)npixels + (long)nmasks) * sizeof(Pixel);
|
||||
data = (XETrapDatum *)ALLOCATE_LOCAL(sizeof(XETrapDatum)+length);
|
||||
data = (XETrapDatum *)xalloc(sizeof(XETrapDatum)+length);
|
||||
if (!data)
|
||||
{
|
||||
SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
|
||||
|
@ -2051,7 +2051,7 @@ static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
|
|||
{
|
||||
SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
|
||||
req->reqType, 0L, retval);
|
||||
DEALLOCATE_LOCAL(data);
|
||||
xfree(data);
|
||||
return;
|
||||
}
|
||||
crep = (xAllocColorCellsReply *)&(data->u.reply);
|
||||
|
@ -2076,7 +2076,7 @@ static void GetSendColorCellsRep(ClientPtr client, xResourceReq *req)
|
|||
SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
|
||||
req->reqType, 0L, XETrapErrorBase + BadIO);
|
||||
}
|
||||
DEALLOCATE_LOCAL(data);
|
||||
xfree(data);
|
||||
}
|
||||
static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
|
||||
{ /* adapted from ProcAllocColorPlanes() in dispatch.c */
|
||||
|
@ -2104,7 +2104,7 @@ static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
|
|||
return;
|
||||
}
|
||||
length = (long)npixels * sizeof(Pixel);
|
||||
data = (XETrapDatum *)ALLOCATE_LOCAL(sizeof(XETrapDatum)+length);
|
||||
data = (XETrapDatum *)xalloc(sizeof(XETrapDatum)+length);
|
||||
if (!data)
|
||||
{
|
||||
SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
|
||||
|
@ -2124,7 +2124,7 @@ static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
|
|||
{
|
||||
SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
|
||||
req->reqType, 0L, retval);
|
||||
DEALLOCATE_LOCAL(data);
|
||||
xfree(data);
|
||||
return;
|
||||
}
|
||||
crep->nPixels = npixels;
|
||||
|
@ -2149,6 +2149,6 @@ static void GetSendColorPlanesRep(ClientPtr client, xResourceReq *req)
|
|||
SendErrorToClient(penv->client, XETrap_avail.data.major_opcode,
|
||||
req->reqType, 0L, XETrapErrorBase + BadIO);
|
||||
}
|
||||
DEALLOCATE_LOCAL(data);
|
||||
xfree(data);
|
||||
}
|
||||
#endif /* COLOR_REPLIES */
|
||||
|
|
|
@ -88,7 +88,7 @@ endif
|
|||
XCALIBRATE_SRCS = xcalibrate.c
|
||||
if XCALIBRATE
|
||||
BUILTIN_SRCS += $(XCALIBRATE_SRCS)
|
||||
# XCalibrare needs tslib
|
||||
# XCalibrate needs tslib
|
||||
endif
|
||||
|
||||
# X EVent Interception Extension: allows accessibility helpers & composite
|
||||
|
|
45
Xext/mbuf.c
45
Xext/mbuf.c
|
@ -403,7 +403,7 @@ CreateImageBuffers (pWin, nbuf, ids, action, hint)
|
|||
pMultibuffer->pMultibuffers = pMultibuffers;
|
||||
if (!AddResource (ids[i], MultibufferResType, (pointer) pMultibuffer))
|
||||
break;
|
||||
pMultibuffer->pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, depth);
|
||||
pMultibuffer->pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, depth, 0);
|
||||
if (!pMultibuffer->pPixmap)
|
||||
break;
|
||||
if (!AddResource (ids[i], MultibufferDrawableResType, (pointer) pMultibuffer->pPixmap))
|
||||
|
@ -524,12 +524,12 @@ ProcDisplayImageBuffers (client)
|
|||
return Success;
|
||||
minDelay = stuff->minDelay;
|
||||
ids = (XID *) &stuff[1];
|
||||
ppMultibuffers = (MultibuffersPtr *) ALLOCATE_LOCAL(nbuf * sizeof (MultibuffersPtr));
|
||||
pMultibuffer = (MultibufferPtr *) ALLOCATE_LOCAL(nbuf * sizeof (MultibufferPtr));
|
||||
ppMultibuffers = (MultibuffersPtr *) xalloc(nbuf * sizeof (MultibuffersPtr));
|
||||
pMultibuffer = (MultibufferPtr *) xalloc(nbuf * sizeof (MultibufferPtr));
|
||||
if (!ppMultibuffers || !pMultibuffer)
|
||||
{
|
||||
if (ppMultibuffers) DEALLOCATE_LOCAL(ppMultibuffers);
|
||||
if (pMultibuffer) DEALLOCATE_LOCAL(pMultibuffer);
|
||||
if (ppMultibuffers) xfree(ppMultibuffers);
|
||||
if (pMultibuffer) xfree(pMultibuffer);
|
||||
client->errorValue = 0;
|
||||
return BadAlloc;
|
||||
}
|
||||
|
@ -541,8 +541,8 @@ ProcDisplayImageBuffers (client)
|
|||
MultibufferResType);
|
||||
if (!pMultibuffer[i])
|
||||
{
|
||||
DEALLOCATE_LOCAL(ppMultibuffers);
|
||||
DEALLOCATE_LOCAL(pMultibuffer);
|
||||
xfree(ppMultibuffers);
|
||||
xfree(pMultibuffer);
|
||||
client->errorValue = ids[i];
|
||||
return MultibufferErrorBase + MultibufferBadBuffer;
|
||||
}
|
||||
|
@ -551,8 +551,8 @@ MultibufferResType);
|
|||
{
|
||||
if (ppMultibuffers[i] == ppMultibuffers[j])
|
||||
{
|
||||
DEALLOCATE_LOCAL(ppMultibuffers);
|
||||
DEALLOCATE_LOCAL(pMultibuffer);
|
||||
xfree(ppMultibuffers);
|
||||
xfree(pMultibuffer);
|
||||
client->errorValue = ids[i];
|
||||
return BadMatch;
|
||||
}
|
||||
|
@ -571,8 +571,8 @@ MultibufferResType);
|
|||
else
|
||||
PerformDisplayRequest (ppMultibuffers, pMultibuffer, nbuf);
|
||||
|
||||
DEALLOCATE_LOCAL(ppMultibuffers);
|
||||
DEALLOCATE_LOCAL(pMultibuffer);
|
||||
xfree(ppMultibuffers);
|
||||
xfree(pMultibuffer);
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
@ -665,7 +665,7 @@ ProcGetMBufferAttributes (client)
|
|||
pMultibuffers = (MultibuffersPtr)LookupIDByType (pWin->drawable.id, MultibuffersResType);
|
||||
if (!pMultibuffers)
|
||||
return BadAccess;
|
||||
ids = (XID *) ALLOCATE_LOCAL (pMultibuffers->numMultibuffer * sizeof (XID));
|
||||
ids = (XID *) xalloc (pMultibuffers->numMultibuffer * sizeof (XID));
|
||||
if (!ids)
|
||||
return BadAlloc;
|
||||
for (i = 0; i < pMultibuffers->numMultibuffer; i++)
|
||||
|
@ -688,7 +688,7 @@ ProcGetMBufferAttributes (client)
|
|||
(char *)&rep);
|
||||
WriteToClient (client, (int)(pMultibuffers->numMultibuffer * sizeof (XID)),
|
||||
(char *)ids);
|
||||
DEALLOCATE_LOCAL((pointer) ids);
|
||||
xfree((pointer) ids);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
|
@ -803,7 +803,7 @@ ProcGetBufferInfo (client)
|
|||
nInfo += pDepth->numVids;
|
||||
}
|
||||
pInfo = (xMbufBufferInfo *)
|
||||
ALLOCATE_LOCAL (nInfo * sizeof (xMbufBufferInfo));
|
||||
xalloc (nInfo * sizeof (xMbufBufferInfo));
|
||||
if (!pInfo)
|
||||
return BadAlloc;
|
||||
|
||||
|
@ -839,7 +839,7 @@ ProcGetBufferInfo (client)
|
|||
}
|
||||
WriteToClient (client, sizeof (xMbufGetBufferInfoReply), (pointer) &rep);
|
||||
WriteToClient (client, (int) nInfo * sizeof (xMbufBufferInfo), (pointer) pInfo);
|
||||
DEALLOCATE_LOCAL ((pointer) pInfo);
|
||||
xfree ((pointer) pInfo);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
|
@ -1256,7 +1256,7 @@ DisplayImageBuffers (ids, nbuf)
|
|||
MultibuffersPtr *pMultibuffers;
|
||||
int i, j;
|
||||
|
||||
pMultibuffer = (MultibufferPtr *) ALLOCATE_LOCAL (nbuf * sizeof *pMultibuffer +
|
||||
pMultibuffer = (MultibufferPtr *) xalloc (nbuf * sizeof *pMultibuffer +
|
||||
nbuf * sizeof *pMultibuffers);
|
||||
if (!pMultibuffer)
|
||||
return BadAlloc;
|
||||
|
@ -1266,19 +1266,19 @@ DisplayImageBuffers (ids, nbuf)
|
|||
pMultibuffer[i] = (MultibufferPtr) LookupIDByType (ids[i], MultibufferResType);
|
||||
if (!pMultibuffer[i])
|
||||
{
|
||||
DEALLOCATE_LOCAL (pMultibuffer);
|
||||
xfree (pMultibuffer);
|
||||
return MultibufferErrorBase + MultibufferBadBuffer;
|
||||
}
|
||||
pMultibuffers[i] = pMultibuffer[i]->pMultibuffers;
|
||||
for (j = 0; j < i; j++)
|
||||
if (pMultibuffers[i] == pMultibuffers[j])
|
||||
{
|
||||
DEALLOCATE_LOCAL (pMultibuffer);
|
||||
xfree (pMultibuffer);
|
||||
return BadMatch;
|
||||
}
|
||||
}
|
||||
PerformDisplayRequest (pMultibuffers, pMultibuffer, nbuf);
|
||||
DEALLOCATE_LOCAL (pMultibuffer);
|
||||
xfree (pMultibuffer);
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
@ -1382,7 +1382,7 @@ MultibufferExpose (pMultibuffer, pRegion)
|
|||
numRects = REGION_NUM_RECTS(pRegion);
|
||||
pBox = REGION_RECTS(pRegion);
|
||||
|
||||
pEvent = (xEvent *) ALLOCATE_LOCAL(numRects * sizeof(xEvent));
|
||||
pEvent = (xEvent *) xalloc(numRects * sizeof(xEvent));
|
||||
if (pEvent) {
|
||||
pe = pEvent;
|
||||
|
||||
|
@ -1398,7 +1398,7 @@ MultibufferExpose (pMultibuffer, pRegion)
|
|||
}
|
||||
(void) DeliverEventsToMultibuffer (pMultibuffer, pEvent, numRects,
|
||||
ExposureMask);
|
||||
DEALLOCATE_LOCAL(pEvent);
|
||||
xfree(pEvent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1576,7 +1576,8 @@ MultibufferPositionWindow (pWin, x, y)
|
|||
{
|
||||
pMultibuffer = &pMultibuffers->buffers[i];
|
||||
pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
|
||||
pWin->drawable.depth);
|
||||
pWin->drawable.depth,
|
||||
CREATE_PIXMAP_USAGE_SCRATCH);
|
||||
if (!pPixmap)
|
||||
{
|
||||
DestroyImageBuffers (pWin);
|
||||
|
|
|
@ -329,10 +329,6 @@ bufCreateBuffer(pScreen, pWin, bufferNum)
|
|||
pBuffer->firstChild = NULL;
|
||||
pBuffer->lastChild = NULL;
|
||||
|
||||
/* XXX - Worry about backingstore later */
|
||||
pBuffer->backStorage = NULL;
|
||||
pBuffer->backingStore = NotUseful;
|
||||
|
||||
/* XXX - Need to call pScreen->CreateWindow for tile/stipples
|
||||
* or should I just copy the devPrivates?
|
||||
*/
|
||||
|
@ -505,22 +501,10 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
|
|||
|
||||
pScreen = pBuffer->drawable.pScreen;
|
||||
REGION_INIT(pScreen, ®, &box, 1);
|
||||
if (pBuffer->backStorage)
|
||||
{
|
||||
/*
|
||||
* If the window has backing-store on, call through the
|
||||
* ClearToBackground vector to handle the special semantics
|
||||
* (i.e. things backing store is to be cleared out and
|
||||
* an Expose event is to be generated for those areas in backing
|
||||
* store if generateExposures is TRUE).
|
||||
*/
|
||||
pBSReg = (* pScreen->ClearBackingStore)(pBuffer, x, y, w, h,
|
||||
generateExposures);
|
||||
}
|
||||
|
||||
REGION_INTERSECT(pScreen, ®, ®, &pBuffer->clipList);
|
||||
if (pBuffer->backgroundState != None)
|
||||
(*pScreen->PaintWindowBackground)(pBuffer, ®, PW_BACKGROUND);
|
||||
miPaintWindow(pBuffer, ®, PW_BACKGROUND);
|
||||
if (generateExposures)
|
||||
MultibufferExpose(pMBBuffer, ®);
|
||||
#ifdef _notdef
|
||||
|
@ -533,7 +517,7 @@ bufClearImageBufferArea(pMBBuffer, x,y, w,h, generateExposures)
|
|||
if (generateExposures)
|
||||
(*pScreen->WindowExposures)(pBuffer, ®, pBSReg);
|
||||
else if (pBuffer->backgroundState != None)
|
||||
(*pScreen->PaintWindowBackground)(pBuffer, ®, PW_BACKGROUND);
|
||||
miPaintWindow(pBuffer, ®, PW_BACKGROUND);
|
||||
#endif
|
||||
REGION_UNINIT(pScreen, ®);
|
||||
if (pBSReg)
|
||||
|
@ -630,7 +614,7 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
|
|||
if (!pGC)
|
||||
return;
|
||||
|
||||
prect = (xRectangle *)ALLOCATE_LOCAL(REGION_NUM_RECTS(prgn) *
|
||||
prect = (xRectangle *)xalloc(REGION_NUM_RECTS(prgn) *
|
||||
sizeof(xRectangle));
|
||||
if (!prect)
|
||||
{
|
||||
|
@ -654,7 +638,7 @@ bufDrawSelectPlane(pScreen, selectPlane, prgn, bufferNum)
|
|||
prect -= numRects;
|
||||
(* pGC->ops->PolyFillRect)(pDrawable, pGC, numRects, prect);
|
||||
|
||||
DEALLOCATE_LOCAL(prect);
|
||||
xfree(prect);
|
||||
FreeScratchGC (pGC);
|
||||
}
|
||||
|
||||
|
@ -852,8 +836,7 @@ bufClipNotify(pWin, dx,dy)
|
|||
|
||||
/*
|
||||
* Updates buffer's background fields when the window's changes.
|
||||
* This is necessary because pScreen->PaintWindowBackground
|
||||
* is used to paint the buffer.
|
||||
* This is necessary because miPaintWindow is used to paint the buffer.
|
||||
*
|
||||
* XXBS - Backingstore state will have be tracked too if it is supported.
|
||||
*/
|
||||
|
@ -943,7 +926,7 @@ bufWindowExposures(pWin, prgn, other_exposed)
|
|||
pBuffer = (BufferPtr) pMBBuffer->pDrawable;
|
||||
|
||||
if (i != pMBWindow->displayedMultibuffer)
|
||||
(* pScreen->PaintWindowBackground)(pBuffer,&tmp_rgn,PW_BACKGROUND);
|
||||
miPaintWindow(pBuffer, &tmp_rgn, PW_BACKGROUND);
|
||||
if ((pMBBuffer->otherEventMask | pMBBuffer->eventMask) & ExposureMask)
|
||||
MultibufferExpose(pMBBuffer, &tmp_rgn);
|
||||
}
|
||||
|
|
|
@ -155,7 +155,7 @@ pixCreateImageBuffers (pWin, nbuf, ids, action, hint)
|
|||
{
|
||||
pMBBuffer = &pMBWindow->buffers[i];
|
||||
pMBBuffer->pDrawable = (DrawablePtr)
|
||||
(*pScreen->CreatePixmap) (pScreen, width, height, depth);
|
||||
(*pScreen->CreatePixmap) (pScreen, width, height, depth, 0);
|
||||
if (!pMBBuffer->pDrawable)
|
||||
break;
|
||||
|
||||
|
@ -263,7 +263,7 @@ MultibufferPaintBackgroundRegion(pWin, pDrawable, pRegion)
|
|||
int nrects = REGION_NUM_RECTS(pRegion);
|
||||
BoxPtr pbox = REGION_RECTS(pRegion);
|
||||
|
||||
pRects = (xRectangle *)ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
|
||||
pRects = (xRectangle *)xalloc(nrects * sizeof(xRectangle));
|
||||
if (pRects)
|
||||
{
|
||||
int i;
|
||||
|
@ -275,7 +275,7 @@ MultibufferPaintBackgroundRegion(pWin, pDrawable, pRegion)
|
|||
pRects[i].height = pbox->y2 - pbox->y1;
|
||||
}
|
||||
MultibufferPaintBackgroundRectangles(pWin, pDrawable, nrects, pRects);
|
||||
DEALLOCATE_LOCAL(pRects);
|
||||
xfree(pRects);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -542,7 +542,8 @@ pixPositionWindow (pWin, x, y)
|
|||
for (i = 0; i < pMBWindow->numMultibuffer; i++)
|
||||
{
|
||||
pMBBuffer = &pMBWindow->buffers[i];
|
||||
pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, pWin->drawable.depth);
|
||||
pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height, pWin->drawable.depth,
|
||||
CREATE_PIXMAP_USAGE_SCRATCH);
|
||||
if (!pPixmap)
|
||||
{
|
||||
(* MB_SCREEN_PRIV(pScreen)->DestroyImageBuffers)(pWin);
|
||||
|
|
|
@ -1272,7 +1272,7 @@ int PanoramiXPolyPoint(ClientPtr client)
|
|||
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
|
||||
npoint = ((client->req_len << 2) - sizeof(xPolyPointReq)) >> 2;
|
||||
if (npoint > 0) {
|
||||
origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
|
||||
origPts = (xPoint *) xalloc(npoint * sizeof(xPoint));
|
||||
memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1299,7 +1299,7 @@ int PanoramiXPolyPoint(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolyPoint])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origPts);
|
||||
xfree(origPts);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1330,7 +1330,7 @@ int PanoramiXPolyLine(ClientPtr client)
|
|||
isRoot = (draw->type == XRT_WINDOW) && draw->u.win.root;
|
||||
npoint = ((client->req_len << 2) - sizeof(xPolyLineReq)) >> 2;
|
||||
if (npoint > 0){
|
||||
origPts = (xPoint *) ALLOCATE_LOCAL(npoint * sizeof(xPoint));
|
||||
origPts = (xPoint *) xalloc(npoint * sizeof(xPoint));
|
||||
memcpy((char *) origPts, (char *) &stuff[1], npoint * sizeof(xPoint));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1357,7 +1357,7 @@ int PanoramiXPolyLine(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolyLine])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origPts);
|
||||
xfree(origPts);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1391,7 +1391,7 @@ int PanoramiXPolySegment(ClientPtr client)
|
|||
if(nsegs & 4) return BadLength;
|
||||
nsegs >>= 3;
|
||||
if (nsegs > 0) {
|
||||
origSegs = (xSegment *) ALLOCATE_LOCAL(nsegs * sizeof(xSegment));
|
||||
origSegs = (xSegment *) xalloc(nsegs * sizeof(xSegment));
|
||||
memcpy((char *) origSegs, (char *) &stuff[1], nsegs * sizeof(xSegment));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1418,7 +1418,7 @@ int PanoramiXPolySegment(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolySegment])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origSegs);
|
||||
xfree(origSegs);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1453,7 +1453,7 @@ int PanoramiXPolyRectangle(ClientPtr client)
|
|||
if(nrects & 4) return BadLength;
|
||||
nrects >>= 3;
|
||||
if (nrects > 0){
|
||||
origRecs = (xRectangle *) ALLOCATE_LOCAL(nrects * sizeof(xRectangle));
|
||||
origRecs = (xRectangle *) xalloc(nrects * sizeof(xRectangle));
|
||||
memcpy((char *)origRecs,(char *)&stuff[1],nrects * sizeof(xRectangle));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1479,7 +1479,7 @@ int PanoramiXPolyRectangle(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolyRectangle])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origRecs);
|
||||
xfree(origRecs);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1513,7 +1513,7 @@ int PanoramiXPolyArc(ClientPtr client)
|
|||
if(narcs % sizeof(xArc)) return BadLength;
|
||||
narcs /= sizeof(xArc);
|
||||
if (narcs > 0){
|
||||
origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
|
||||
origArcs = (xArc *) xalloc(narcs * sizeof(xArc));
|
||||
memcpy((char *) origArcs, (char *) &stuff[1], narcs * sizeof(xArc));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1537,7 +1537,7 @@ int PanoramiXPolyArc(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolyArc])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origArcs);
|
||||
xfree(origArcs);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1569,7 +1569,7 @@ int PanoramiXFillPoly(ClientPtr client)
|
|||
|
||||
count = ((client->req_len << 2) - sizeof(xFillPolyReq)) >> 2;
|
||||
if (count > 0){
|
||||
locPts = (DDXPointPtr) ALLOCATE_LOCAL(count * sizeof(DDXPointRec));
|
||||
locPts = (DDXPointPtr) xalloc(count * sizeof(DDXPointRec));
|
||||
memcpy((char *)locPts, (char *)&stuff[1], count * sizeof(DDXPointRec));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1596,7 +1596,7 @@ int PanoramiXFillPoly(ClientPtr client)
|
|||
result = (* SavedProcVector[X_FillPoly])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(locPts);
|
||||
xfree(locPts);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1630,7 +1630,7 @@ int PanoramiXPolyFillRectangle(ClientPtr client)
|
|||
if(things & 4) return BadLength;
|
||||
things >>= 3;
|
||||
if (things > 0){
|
||||
origRects = (xRectangle *) ALLOCATE_LOCAL(things * sizeof(xRectangle));
|
||||
origRects = (xRectangle *) xalloc(things * sizeof(xRectangle));
|
||||
memcpy((char*)origRects,(char*)&stuff[1], things * sizeof(xRectangle));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1655,7 +1655,7 @@ int PanoramiXPolyFillRectangle(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolyFillRectangle])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origRects);
|
||||
xfree(origRects);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
@ -1689,7 +1689,7 @@ int PanoramiXPolyFillArc(ClientPtr client)
|
|||
IF_RETURN((narcs % sizeof(xArc)), BadLength);
|
||||
narcs /= sizeof(xArc);
|
||||
if (narcs > 0) {
|
||||
origArcs = (xArc *) ALLOCATE_LOCAL(narcs * sizeof(xArc));
|
||||
origArcs = (xArc *) xalloc(narcs * sizeof(xArc));
|
||||
memcpy((char *) origArcs, (char *)&stuff[1], narcs * sizeof(xArc));
|
||||
FOR_NSCREENS_FORWARD(j){
|
||||
|
||||
|
@ -1714,7 +1714,7 @@ int PanoramiXPolyFillArc(ClientPtr client)
|
|||
result = (* SavedProcVector[X_PolyFillArc])(client);
|
||||
if(result != Success) break;
|
||||
}
|
||||
DEALLOCATE_LOCAL(origArcs);
|
||||
xfree(origArcs);
|
||||
return (result);
|
||||
} else
|
||||
return (client->noClientException);
|
||||
|
|
|
@ -673,7 +673,7 @@ CreateSaverWindow (pScreen)
|
|||
wantMap = wColormap (pWin);
|
||||
if (wantMap == None)
|
||||
return TRUE;
|
||||
installedMaps = (Colormap *) ALLOCATE_LOCAL (pScreen->maxInstalledCmaps *
|
||||
installedMaps = (Colormap *) xalloc (pScreen->maxInstalledCmaps *
|
||||
sizeof (Colormap));
|
||||
numInstalled = (*pWin->drawable.pScreen->ListInstalledColormaps)
|
||||
(pScreen, installedMaps);
|
||||
|
@ -681,7 +681,7 @@ CreateSaverWindow (pScreen)
|
|||
if (installedMaps[i] == wantMap)
|
||||
break;
|
||||
|
||||
DEALLOCATE_LOCAL ((char *) installedMaps);
|
||||
xfree ((char *) installedMaps);
|
||||
|
||||
if (i < numInstalled)
|
||||
return TRUE;
|
||||
|
|
|
@ -1060,7 +1060,7 @@ ProcShapeGetRectangles (client)
|
|||
}
|
||||
if (!region) {
|
||||
nrects = 1;
|
||||
rects = (xRectangle *) ALLOCATE_LOCAL (sizeof (xRectangle));
|
||||
rects = (xRectangle *) xalloc (sizeof (xRectangle));
|
||||
if (!rects)
|
||||
return BadAlloc;
|
||||
switch (stuff->kind) {
|
||||
|
@ -1087,7 +1087,7 @@ ProcShapeGetRectangles (client)
|
|||
BoxPtr box;
|
||||
nrects = REGION_NUM_RECTS(region);
|
||||
box = REGION_RECTS(region);
|
||||
rects = (xRectangle *) ALLOCATE_LOCAL (nrects * sizeof (xRectangle));
|
||||
rects = (xRectangle *) xalloc (nrects * sizeof (xRectangle));
|
||||
if (!rects && nrects)
|
||||
return BadAlloc;
|
||||
for (i = 0; i < nrects; i++, box++) {
|
||||
|
@ -1110,7 +1110,7 @@ ProcShapeGetRectangles (client)
|
|||
}
|
||||
WriteToClient (client, sizeof (rep), (char *) &rep);
|
||||
WriteToClient (client, nrects * sizeof (xRectangle), (char *) rects);
|
||||
DEALLOCATE_LOCAL (rects);
|
||||
xfree (rects);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
|
|
111
Xext/shm.c
111
Xext/shm.c
|
@ -57,10 +57,38 @@ in this Software without prior written authorization from The Open Group.
|
|||
#include "gcstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#include "servermd.h"
|
||||
#include "shmint.h"
|
||||
#define _XSHM_SERVER_
|
||||
#include <X11/extensions/shmstr.h>
|
||||
#include <X11/Xfuncproto.h>
|
||||
|
||||
/* Needed for Solaris cross-zone shared memory extension */
|
||||
#ifdef HAVE_SHMCTL64
|
||||
#include <sys/ipc_impl.h>
|
||||
#define SHMSTAT(id, buf) shmctl64(id, IPC_STAT64, buf)
|
||||
#define SHMSTAT_TYPE struct shmid_ds64
|
||||
#define SHMPERM_TYPE struct ipc_perm64
|
||||
#define SHM_PERM(buf) buf.shmx_perm
|
||||
#define SHM_SEGSZ(buf) buf.shmx_segsz
|
||||
#define SHMPERM_UID(p) p->ipcx_uid
|
||||
#define SHMPERM_CUID(p) p->ipcx_cuid
|
||||
#define SHMPERM_GID(p) p->ipcx_gid
|
||||
#define SHMPERM_CGID(p) p->ipcx_cgid
|
||||
#define SHMPERM_MODE(p) p->ipcx_mode
|
||||
#define SHMPERM_ZONEID(p) p->ipcx_zoneid
|
||||
#else
|
||||
#define SHMSTAT(id, buf) shmctl(id, IPC_STAT, buf)
|
||||
#define SHMSTAT_TYPE struct shmid_ds
|
||||
#define SHMPERM_TYPE struct ipc_perm
|
||||
#define SHM_PERM(buf) buf.shm_perm
|
||||
#define SHM_SEGSZ(buf) buf.shm_segsz
|
||||
#define SHMPERM_UID(p) p->uid
|
||||
#define SHMPERM_CUID(p) p->cuid
|
||||
#define SHMPERM_GID(p) p->gid
|
||||
#define SHMPERM_CGID(p) p->cgid
|
||||
#define SHMPERM_MODE(p) p->mode
|
||||
#endif
|
||||
|
||||
#ifdef PANORAMIX
|
||||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
|
@ -78,7 +106,6 @@ typedef struct _ShmDesc {
|
|||
} ShmDescRec, *ShmDescPtr;
|
||||
|
||||
static void miShmPutImage(XSHM_PUT_IMAGE_ARGS);
|
||||
static void fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
|
||||
static PixmapPtr fbShmCreatePixmap(XSHM_CREATE_PIXMAP_ARGS);
|
||||
static int ShmDetachSegment(
|
||||
pointer /* value */,
|
||||
|
@ -154,7 +181,7 @@ static ShmFuncs fbFuncs = {fbShmCreatePixmap, fbShmPutImage};
|
|||
}
|
||||
|
||||
|
||||
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__)
|
||||
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__DragonFly__)
|
||||
#include <sys/signal.h>
|
||||
|
||||
static Bool badSysCall = FALSE;
|
||||
|
@ -348,32 +375,57 @@ ProcShmQueryVersion(client)
|
|||
* using the credentials from the client if available
|
||||
*/
|
||||
static int
|
||||
shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
|
||||
shm_access(ClientPtr client, SHMPERM_TYPE *perm, int readonly)
|
||||
{
|
||||
int uid, gid;
|
||||
mode_t mask;
|
||||
int uidset = 0, gidset = 0;
|
||||
LocalClientCredRec *lcc;
|
||||
|
||||
if (GetLocalClientCreds(client, &lcc) != -1) {
|
||||
|
||||
if (LocalClientCred(client, &uid, &gid) != -1) {
|
||||
if (lcc->fieldsSet & LCC_UID_SET) {
|
||||
uid = lcc->euid;
|
||||
uidset = 1;
|
||||
}
|
||||
if (lcc->fieldsSet & LCC_GID_SET) {
|
||||
gid = lcc->egid;
|
||||
gidset = 1;
|
||||
}
|
||||
|
||||
#if defined(HAVE_GETZONEID) && defined(SHMPERM_ZONEID)
|
||||
if ( ((lcc->fieldsSet & LCC_ZID_SET) == 0) || (lcc->zoneid == -1)
|
||||
|| (lcc->zoneid != SHMPERM_ZONEID(perm))) {
|
||||
uidset = 0;
|
||||
gidset = 0;
|
||||
}
|
||||
#endif
|
||||
FreeLocalClientCreds(lcc);
|
||||
|
||||
/* User id 0 always gets access */
|
||||
if (uid == 0) {
|
||||
return 0;
|
||||
}
|
||||
/* Check the owner */
|
||||
if (perm->uid == uid || perm->cuid == uid) {
|
||||
mask = S_IRUSR;
|
||||
if (!readonly) {
|
||||
mask |= S_IWUSR;
|
||||
if (uidset) {
|
||||
/* User id 0 always gets access */
|
||||
if (uid == 0) {
|
||||
return 0;
|
||||
}
|
||||
return (perm->mode & mask) == mask ? 0 : -1;
|
||||
}
|
||||
/* Check the group */
|
||||
if (perm->gid == gid || perm->cgid == gid) {
|
||||
mask = S_IRGRP;
|
||||
if (!readonly) {
|
||||
mask |= S_IWGRP;
|
||||
/* Check the owner */
|
||||
if (SHMPERM_UID(perm) == uid || SHMPERM_CUID(perm) == uid) {
|
||||
mask = S_IRUSR;
|
||||
if (!readonly) {
|
||||
mask |= S_IWUSR;
|
||||
}
|
||||
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (gidset) {
|
||||
/* Check the group */
|
||||
if (SHMPERM_GID(perm) == gid || SHMPERM_CGID(perm) == gid) {
|
||||
mask = S_IRGRP;
|
||||
if (!readonly) {
|
||||
mask |= S_IWGRP;
|
||||
}
|
||||
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
||||
}
|
||||
return (perm->mode & mask) == mask ? 0 : -1;
|
||||
}
|
||||
}
|
||||
/* Otherwise, check everyone else */
|
||||
|
@ -381,14 +433,14 @@ shm_access(ClientPtr client, struct ipc_perm *perm, int readonly)
|
|||
if (!readonly) {
|
||||
mask |= S_IWOTH;
|
||||
}
|
||||
return (perm->mode & mask) == mask ? 0 : -1;
|
||||
return (SHMPERM_MODE(perm) & mask) == mask ? 0 : -1;
|
||||
}
|
||||
|
||||
static int
|
||||
ProcShmAttach(client)
|
||||
register ClientPtr client;
|
||||
{
|
||||
struct shmid_ds buf;
|
||||
SHMSTAT_TYPE buf;
|
||||
ShmDescPtr shmdesc;
|
||||
REQUEST(xShmAttachReq);
|
||||
|
||||
|
@ -417,7 +469,7 @@ ProcShmAttach(client)
|
|||
shmdesc->addr = shmat(stuff->shmid, 0,
|
||||
stuff->readOnly ? SHM_RDONLY : 0);
|
||||
if ((shmdesc->addr == ((char *)-1)) ||
|
||||
shmctl(stuff->shmid, IPC_STAT, &buf))
|
||||
SHMSTAT(stuff->shmid, &buf))
|
||||
{
|
||||
xfree(shmdesc);
|
||||
return BadAccess;
|
||||
|
@ -427,7 +479,7 @@ ProcShmAttach(client)
|
|||
* do manual checking of access rights for the credentials
|
||||
* of the client */
|
||||
|
||||
if (shm_access(client, &(buf.shm_perm), stuff->readOnly) == -1) {
|
||||
if (shm_access(client, &(SHM_PERM(buf)), stuff->readOnly) == -1) {
|
||||
shmdt(shmdesc->addr);
|
||||
xfree(shmdesc);
|
||||
return BadAccess;
|
||||
|
@ -436,7 +488,7 @@ ProcShmAttach(client)
|
|||
shmdesc->shmid = stuff->shmid;
|
||||
shmdesc->refcnt = 1;
|
||||
shmdesc->writable = !stuff->readOnly;
|
||||
shmdesc->size = buf.shm_segsz;
|
||||
shmdesc->size = SHM_SEGSZ(buf);
|
||||
shmdesc->next = Shmsegs;
|
||||
Shmsegs = shmdesc;
|
||||
}
|
||||
|
@ -491,7 +543,8 @@ miShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
|
|||
putGC = GetScratchGC(depth, dst->pScreen);
|
||||
if (!putGC)
|
||||
return;
|
||||
pmap = (*dst->pScreen->CreatePixmap)(dst->pScreen, sw, sh, depth);
|
||||
pmap = (*dst->pScreen->CreatePixmap)(dst->pScreen, sw, sh, depth,
|
||||
CREATE_PIXMAP_USAGE_SCRATCH);
|
||||
if (!pmap)
|
||||
{
|
||||
FreeScratchGC(putGC);
|
||||
|
@ -510,7 +563,7 @@ miShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
|
|||
(*pmap->drawable.pScreen->DestroyPixmap)(pmap);
|
||||
}
|
||||
|
||||
static void
|
||||
_X_EXPORT void
|
||||
fbShmPutImage(dst, pGC, depth, format, w, h, sx, sy, sw, sh, dx, dy, data)
|
||||
DrawablePtr dst;
|
||||
GCPtr pGC;
|
||||
|
@ -1018,7 +1071,7 @@ fbShmCreatePixmap (pScreen, width, height, depth, addr)
|
|||
{
|
||||
register PixmapPtr pPixmap;
|
||||
|
||||
pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreen->rootDepth);
|
||||
pPixmap = (*pScreen->CreatePixmap)(pScreen, 0, 0, pScreen->rootDepth, 0);
|
||||
if (!pPixmap)
|
||||
return NullPixmap;
|
||||
|
||||
|
|
|
@ -36,6 +36,9 @@ ShmRegisterFuncs(ScreenPtr pScreen, ShmFuncsPtr funcs);
|
|||
void
|
||||
ShmSetPixmapFormat(ScreenPtr pScreen, int format);
|
||||
|
||||
void
|
||||
fbShmPutImage(XSHM_PUT_IMAGE_ARGS);
|
||||
|
||||
void
|
||||
ShmRegisterFbFuncs(ScreenPtr pScreen);
|
||||
|
||||
|
|
17
Xext/sync.c
17
Xext/sync.c
|
@ -601,7 +601,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
|
|||
if (client->clientGone)
|
||||
return;
|
||||
pev = pEvents = (xSyncCounterNotifyEvent *)
|
||||
ALLOCATE_LOCAL(num_events * sizeof(xSyncCounterNotifyEvent));
|
||||
xalloc(num_events * sizeof(xSyncCounterNotifyEvent));
|
||||
if (!pEvents)
|
||||
return;
|
||||
UpdateCurrentTime();
|
||||
|
@ -622,7 +622,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
|
|||
}
|
||||
/* swapping will be taken care of by this */
|
||||
WriteEventsToClient(client, num_events, (xEvent *)pEvents);
|
||||
DEALLOCATE_LOCAL(pEvents);
|
||||
xfree(pEvents);
|
||||
}
|
||||
|
||||
|
||||
|
@ -732,7 +732,7 @@ SyncAwaitTriggerFired(pTrigger)
|
|||
|
||||
pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;
|
||||
numwaits = pAwaitUnion->header.num_waitconditions;
|
||||
ppAwait = (SyncAwait **)ALLOCATE_LOCAL(numwaits * sizeof(SyncAwait *));
|
||||
ppAwait = (SyncAwait **)xalloc(numwaits * sizeof(SyncAwait *));
|
||||
if (!ppAwait)
|
||||
goto bail;
|
||||
|
||||
|
@ -801,7 +801,7 @@ SyncAwaitTriggerFired(pTrigger)
|
|||
if (num_events)
|
||||
SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
|
||||
num_events);
|
||||
DEALLOCATE_LOCAL(ppAwait);
|
||||
xfree(ppAwait);
|
||||
|
||||
bail:
|
||||
/* unblock the client */
|
||||
|
@ -1396,7 +1396,7 @@ ProcSyncListSystemCounters(client)
|
|||
|
||||
if (len)
|
||||
{
|
||||
walklist = list = (xSyncSystemCounter *) ALLOCATE_LOCAL(len);
|
||||
walklist = list = (xSyncSystemCounter *) xalloc(len);
|
||||
if (!list)
|
||||
return BadAlloc;
|
||||
}
|
||||
|
@ -1442,7 +1442,7 @@ ProcSyncListSystemCounters(client)
|
|||
if (len)
|
||||
{
|
||||
WriteToClient(client, len, (char *) list);
|
||||
DEALLOCATE_LOCAL(list);
|
||||
xfree(list);
|
||||
}
|
||||
|
||||
return (client->noClientException);
|
||||
|
@ -2592,8 +2592,9 @@ IdleTimeWakeupHandler (pointer env,
|
|||
IdleTimeQueryValue (NULL, &idle);
|
||||
|
||||
if ((pIdleTimeValueGreater &&
|
||||
XSyncValueGreaterThan (idle, *pIdleTimeValueGreater)) ||
|
||||
(pIdleTimeValueLess && XSyncValueLessThan (idle, *pIdleTimeValueLess)))
|
||||
XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) ||
|
||||
(pIdleTimeValueLess &&
|
||||
XSyncValueLessOrEqual (idle, *pIdleTimeValueLess)))
|
||||
{
|
||||
SyncChangeCounter (IdleTimeCounter, idle);
|
||||
}
|
||||
|
|
51
Xext/xace.c
51
Xext/xace.c
|
@ -44,6 +44,22 @@ static int (*SwappedUntrustedProcVector[256])(
|
|||
ClientPtr /*client*/
|
||||
);
|
||||
|
||||
/* Special-cased hook functions. Called by Xserver.
|
||||
*/
|
||||
void XaceHookAuditBegin(ClientPtr ptr)
|
||||
{
|
||||
XaceAuditRec rec = { ptr, 0 };
|
||||
/* call callbacks, there is no return value. */
|
||||
CallCallbacks(&XaceHooks[XACE_AUDIT_BEGIN], &rec);
|
||||
}
|
||||
|
||||
void XaceHookAuditEnd(ClientPtr ptr, int result)
|
||||
{
|
||||
XaceAuditRec rec = { ptr, result };
|
||||
/* call callbacks, there is no return value. */
|
||||
CallCallbacks(&XaceHooks[XACE_AUDIT_END], &rec);
|
||||
}
|
||||
|
||||
/* Entry point for hook functions. Called by Xserver.
|
||||
*/
|
||||
int XaceHook(int hook, ...)
|
||||
|
@ -60,15 +76,6 @@ int XaceHook(int hook, ...)
|
|||
*/
|
||||
switch (hook)
|
||||
{
|
||||
case XACE_CORE_DISPATCH: {
|
||||
XaceCoreDispatchRec rec = {
|
||||
va_arg(ap, ClientPtr),
|
||||
TRUE /* default allow */
|
||||
};
|
||||
calldata = &rec;
|
||||
prv = &rec.rval;
|
||||
break;
|
||||
}
|
||||
case XACE_RESOURCE_ACCESS: {
|
||||
XaceResourceAccessRec rec = {
|
||||
va_arg(ap, ClientPtr),
|
||||
|
@ -190,22 +197,6 @@ int XaceHook(int hook, ...)
|
|||
calldata = &rec;
|
||||
break;
|
||||
}
|
||||
case XACE_AUDIT_BEGIN: {
|
||||
XaceAuditRec rec = {
|
||||
va_arg(ap, ClientPtr),
|
||||
0
|
||||
};
|
||||
calldata = &rec;
|
||||
break;
|
||||
}
|
||||
case XACE_AUDIT_END: {
|
||||
XaceAuditRec rec = {
|
||||
va_arg(ap, ClientPtr),
|
||||
va_arg(ap, int)
|
||||
};
|
||||
calldata = &rec;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
va_end(ap);
|
||||
return 0; /* unimplemented hook number */
|
||||
|
@ -271,11 +262,15 @@ XaceCatchDispatchProc(ClientPtr client)
|
|||
{
|
||||
REQUEST(xReq);
|
||||
int major = stuff->reqType;
|
||||
XaceCoreDispatchRec rec = { client, TRUE /* default allow */ };
|
||||
|
||||
if (!ProcVector[major])
|
||||
return (BadRequest);
|
||||
|
||||
if (!XaceHook(XACE_CORE_DISPATCH, client))
|
||||
/* call callbacks and return result, if any. */
|
||||
CallCallbacks(&XaceHooks[XACE_CORE_DISPATCH], &rec);
|
||||
|
||||
if (!rec.rval)
|
||||
return (BadAccess);
|
||||
|
||||
return client->swapped ?
|
||||
|
@ -437,7 +432,7 @@ XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
|
|||
|
||||
/* convert region to list-of-rectangles for PolyFillRect */
|
||||
|
||||
pRects = (xRectangle *)ALLOCATE_LOCAL(nRects * sizeof(xRectangle *));
|
||||
pRects = (xRectangle *)xalloc(nRects * sizeof(xRectangle *));
|
||||
if (!pRects)
|
||||
{
|
||||
failed = TRUE;
|
||||
|
@ -489,7 +484,7 @@ XaceCensorImage(client, pVisibleRegion, widthBytesLine, pDraw, x, y, w, h,
|
|||
*/
|
||||
bzero(pBuf, (int)(widthBytesLine * h));
|
||||
}
|
||||
if (pRects) DEALLOCATE_LOCAL(pRects);
|
||||
if (pRects) xfree(pRects);
|
||||
if (pScratchGC) FreeScratchGC(pScratchGC);
|
||||
if (pPix) FreeScratchPixmapHeader(pPix);
|
||||
}
|
||||
|
|
|
@ -68,6 +68,11 @@ extern int XaceHook(
|
|||
... /*appropriate args for hook*/
|
||||
);
|
||||
|
||||
/* Special-cased hook functions
|
||||
*/
|
||||
extern void XaceHookAuditEnd(ClientPtr ptr, int result);
|
||||
extern void XaceHookAuditBegin(ClientPtr ptr);
|
||||
|
||||
/* Register a callback for a given hook.
|
||||
*/
|
||||
#define XaceRegisterCallback(hook,callback,data) \
|
||||
|
@ -98,9 +103,13 @@ extern void XaceCensorImage(
|
|||
|
||||
#ifdef __GNUC__
|
||||
#define XaceHook(args...) XaceAllowOperation
|
||||
#define XaceHookAuditEnd(args...) { ; }
|
||||
#define XaceHookAuditBegin(args...) { ; }
|
||||
#define XaceCensorImage(args...) { ; }
|
||||
#else
|
||||
#define XaceHook(...) XaceAllowOperation
|
||||
#define XaceHookAuditEnd(...) { ; }
|
||||
#define XaceHookAuditBegin(...) { ; }
|
||||
#define XaceCensorImage(...) { ; }
|
||||
#endif
|
||||
|
||||
|
|
|
@ -104,7 +104,7 @@ static unsigned int pagesize;
|
|||
|
||||
static Bool badSysCall = FALSE;
|
||||
|
||||
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__)
|
||||
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__DragonFly__)
|
||||
|
||||
#include <sys/signal.h>
|
||||
|
||||
|
@ -491,7 +491,7 @@ ProcXF86BigfontQueryFont(
|
|||
} else {
|
||||
#endif
|
||||
pCI = (xCharInfo *)
|
||||
ALLOCATE_LOCAL(nCharInfos * sizeof(xCharInfo));
|
||||
xalloc(nCharInfos * sizeof(xCharInfo));
|
||||
if (!pCI)
|
||||
return BadAlloc;
|
||||
#ifdef HAS_SHM
|
||||
|
@ -554,9 +554,9 @@ ProcXF86BigfontQueryFont(
|
|||
hashModulus = nCharInfos+1;
|
||||
|
||||
tmp = (CARD16*)
|
||||
ALLOCATE_LOCAL((4*nCharInfos+1) * sizeof(CARD16));
|
||||
xalloc((4*nCharInfos+1) * sizeof(CARD16));
|
||||
if (!tmp) {
|
||||
if (!pDesc) DEALLOCATE_LOCAL(pCI);
|
||||
if (!pDesc) xfree(pCI);
|
||||
return BadAlloc;
|
||||
}
|
||||
pIndex2UniqIndex = tmp;
|
||||
|
@ -639,12 +639,12 @@ ProcXF86BigfontQueryFont(
|
|||
+ (nCharInfos+1)/2 * 2 * sizeof(CARD16)
|
||||
: 0);
|
||||
xXF86BigfontQueryFontReply* reply =
|
||||
(xXF86BigfontQueryFontReply *) ALLOCATE_LOCAL(rlength);
|
||||
(xXF86BigfontQueryFontReply *) xalloc(rlength);
|
||||
char* p;
|
||||
if (!reply) {
|
||||
if (nCharInfos > 0) {
|
||||
if (shmid == -1) DEALLOCATE_LOCAL(pIndex2UniqIndex);
|
||||
if (!pDesc) DEALLOCATE_LOCAL(pCI);
|
||||
if (shmid == -1) xfree(pIndex2UniqIndex);
|
||||
if (!pDesc) xfree(pCI);
|
||||
}
|
||||
return BadAlloc;
|
||||
}
|
||||
|
@ -722,10 +722,10 @@ ProcXF86BigfontQueryFont(
|
|||
}
|
||||
}
|
||||
WriteToClient(client, rlength, (char *)reply);
|
||||
DEALLOCATE_LOCAL(reply);
|
||||
xfree(reply);
|
||||
if (nCharInfos > 0) {
|
||||
if (shmid == -1) DEALLOCATE_LOCAL(pIndex2UniqIndex);
|
||||
if (!pDesc) DEALLOCATE_LOCAL(pCI);
|
||||
if (shmid == -1) xfree(pIndex2UniqIndex);
|
||||
if (!pDesc) xfree(pCI);
|
||||
}
|
||||
return (client->noClientException);
|
||||
}
|
||||
|
|
|
@ -63,7 +63,7 @@ ProcXResQueryClients (ClientPtr client)
|
|||
|
||||
REQUEST_SIZE_MATCH(xXResQueryClientsReq);
|
||||
|
||||
current_clients = ALLOCATE_LOCAL((currentMaxClients - 1) * sizeof(int));
|
||||
current_clients = xalloc((currentMaxClients - 1) * sizeof(int));
|
||||
|
||||
num_clients = 0;
|
||||
for(i = 1; i < currentMaxClients; i++) {
|
||||
|
@ -101,7 +101,7 @@ ProcXResQueryClients (ClientPtr client)
|
|||
}
|
||||
}
|
||||
|
||||
DEALLOCATE_LOCAL(current_clients);
|
||||
xfree(current_clients);
|
||||
|
||||
return (client->noClientException);
|
||||
}
|
||||
|
@ -134,7 +134,7 @@ ProcXResQueryClientResources (ClientPtr client)
|
|||
return BadValue;
|
||||
}
|
||||
|
||||
counts = ALLOCATE_LOCAL((lastResourceType + 1) * sizeof(int));
|
||||
counts = xalloc((lastResourceType + 1) * sizeof(int));
|
||||
|
||||
memset(counts, 0, (lastResourceType + 1) * sizeof(int));
|
||||
|
||||
|
@ -183,7 +183,7 @@ ProcXResQueryClientResources (ClientPtr client)
|
|||
}
|
||||
}
|
||||
|
||||
DEALLOCATE_LOCAL(counts);
|
||||
xfree(counts);
|
||||
|
||||
return (client->noClientException);
|
||||
}
|
||||
|
|
12
Xi/allowev.c
12
Xi/allowev.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -103,10 +100,8 @@ ProcXAllowDeviceEvents(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xAllowDeviceEventsReq);
|
||||
|
||||
thisdev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (thisdev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (thisdev == NULL)
|
||||
return BadDevice;
|
||||
time = ClientTimeToServerTime(stuff->time);
|
||||
|
||||
switch (stuff->mode) {
|
||||
|
@ -129,9 +124,8 @@ ProcXAllowDeviceEvents(ClientPtr client)
|
|||
AllowSome(client, time, thisdev, THAWED_BOTH, FALSE);
|
||||
break;
|
||||
default:
|
||||
SendErrorToClient(client, IReqCode, X_AllowDeviceEvents, 0, BadValue);
|
||||
client->errorValue = stuff->mode;
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
return Success;
|
||||
}
|
||||
|
|
15
Xi/chgdctl.c
15
Xi/chgdctl.c
|
@ -56,14 +56,11 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h> /* control constants */
|
||||
#include "XIstubs.h"
|
||||
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "exevents.h"
|
||||
|
@ -153,11 +150,8 @@ ProcXChangeDeviceControl(ClientPtr client)
|
|||
a = &dev->valuator->axes[r->first_valuator];
|
||||
for (i = 0; i < r->num_valuators; i++)
|
||||
if (*(resolution + i) < (a + i)->min_resolution ||
|
||||
*(resolution + i) > (a + i)->max_resolution) {
|
||||
SendErrorToClient(client, IReqCode,
|
||||
X_ChangeDeviceControl, 0, BadValue);
|
||||
return Success;
|
||||
}
|
||||
*(resolution + i) > (a + i)->max_resolution)
|
||||
return BadValue;
|
||||
for (i = 0; i < r->num_valuators; i++)
|
||||
(a++)->resolution = *resolution++;
|
||||
|
||||
|
@ -269,11 +263,8 @@ out:
|
|||
|
||||
WriteReplyToClient(client, sizeof(xChangeDeviceControlReply), &rep);
|
||||
}
|
||||
else {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceControl, 0, ret);
|
||||
}
|
||||
|
||||
return Success;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
|
179
Xi/chgfctl.c
179
Xi/chgfctl.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h> /* control constants */
|
||||
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -119,9 +116,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
t = defaultKeyboardControl.click;
|
||||
else if (t < 0 || t > 100) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
kctrl.click = t;
|
||||
}
|
||||
|
@ -132,9 +127,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
t = defaultKeyboardControl.bell;
|
||||
else if (t < 0 || t > 100) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
kctrl.bell = t;
|
||||
}
|
||||
|
@ -145,9 +138,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
t = defaultKeyboardControl.bell_pitch;
|
||||
else if (t < 0) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
kctrl.bell_pitch = t;
|
||||
}
|
||||
|
@ -158,9 +149,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
t = defaultKeyboardControl.bell_duration;
|
||||
else if (t < 0) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
kctrl.bell_duration = t;
|
||||
}
|
||||
|
@ -174,15 +163,10 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
key = (KeyCode) f->key;
|
||||
if (key < 8 || key > 255) {
|
||||
client->errorValue = key;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
}
|
||||
if (!(mask & DvAutoRepeatMode)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
if (!(mask & DvAutoRepeatMode))
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
if (mask & DvAutoRepeatMode) {
|
||||
|
@ -210,9 +194,7 @@ ChangeKbdFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
(defaultKeyboardControl.autoRepeats[inx] & kmask);
|
||||
} else {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -250,9 +232,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
pctrl.num = defaultPointerControl.num;
|
||||
else if (accelNum < 0) {
|
||||
client->errorValue = accelNum;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
} else
|
||||
pctrl.num = accelNum;
|
||||
}
|
||||
|
@ -265,9 +245,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
pctrl.den = defaultPointerControl.den;
|
||||
else if (accelDenom <= 0) {
|
||||
client->errorValue = accelDenom;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
} else
|
||||
pctrl.den = accelDenom;
|
||||
}
|
||||
|
@ -280,9 +258,7 @@ ChangePtrFeedback(ClientPtr client, DeviceIntPtr dev, long unsigned int mask,
|
|||
pctrl.threshold = defaultPointerControl.threshold;
|
||||
else if (threshold < 0) {
|
||||
client->errorValue = threshold;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
} else
|
||||
pctrl.threshold = threshold;
|
||||
}
|
||||
|
@ -341,21 +317,16 @@ ChangeStringFeedback(ClientPtr client, DeviceIntPtr dev,
|
|||
}
|
||||
}
|
||||
|
||||
if (f->num_keysyms > s->ctrl.max_symbols) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
}
|
||||
if (f->num_keysyms > s->ctrl.max_symbols)
|
||||
return BadValue;
|
||||
|
||||
sup_syms = s->ctrl.symbols_supported;
|
||||
for (i = 0; i < f->num_keysyms; i++) {
|
||||
for (j = 0; j < s->ctrl.num_symbols_supported; j++)
|
||||
if (*(syms + i) == *(sup_syms + j))
|
||||
break;
|
||||
if (j == s->ctrl.num_symbols_supported) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (j == s->ctrl.num_symbols_supported)
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
s->ctrl.num_symbols_displayed = f->num_keysyms;
|
||||
|
@ -393,9 +364,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
|
|||
t = defaultKeyboardControl.bell;
|
||||
else if (t < 0 || t > 100) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
bctrl.percent = t;
|
||||
}
|
||||
|
@ -406,9 +375,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
|
|||
t = defaultKeyboardControl.bell_pitch;
|
||||
else if (t < 0) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
bctrl.pitch = t;
|
||||
}
|
||||
|
@ -419,9 +386,7 @@ ChangeBellFeedback(ClientPtr client, DeviceIntPtr dev,
|
|||
t = defaultKeyboardControl.bell_duration;
|
||||
else if (t < 0) {
|
||||
client->errorValue = t;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
bctrl.duration = t;
|
||||
}
|
||||
|
@ -485,38 +450,27 @@ ProcXChangeFeedbackControl(ClientPtr client)
|
|||
|
||||
len = stuff->length - (sizeof(xChangeFeedbackControlReq) >> 2);
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
switch (stuff->feedbackid) {
|
||||
case KbdFeedbackClass:
|
||||
if (len != (sizeof(xKbdFeedbackCtl) >> 2)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (len != (sizeof(xKbdFeedbackCtl) >> 2))
|
||||
return BadLength;
|
||||
|
||||
for (k = dev->kbdfeed; k; k = k->next)
|
||||
if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id) {
|
||||
ChangeKbdFeedback(client, dev, stuff->mask, k,
|
||||
(xKbdFeedbackCtl *) & stuff[1]);
|
||||
return Success;
|
||||
}
|
||||
if (k->ctrl.id == ((xKbdFeedbackCtl *) & stuff[1])->id)
|
||||
return ChangeKbdFeedback(client, dev, stuff->mask, k,
|
||||
(xKbdFeedbackCtl *) & stuff[1]);
|
||||
break;
|
||||
case PtrFeedbackClass:
|
||||
if (len != (sizeof(xPtrFeedbackCtl) >> 2)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (len != (sizeof(xPtrFeedbackCtl) >> 2))
|
||||
return BadLength;
|
||||
|
||||
for (p = dev->ptrfeed; p; p = p->next)
|
||||
if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id) {
|
||||
ChangePtrFeedback(client, dev, stuff->mask, p,
|
||||
(xPtrFeedbackCtl *) & stuff[1]);
|
||||
return Success;
|
||||
}
|
||||
if (p->ctrl.id == ((xPtrFeedbackCtl *) & stuff[1])->id)
|
||||
return ChangePtrFeedback(client, dev, stuff->mask, p,
|
||||
(xPtrFeedbackCtl *) & stuff[1]);
|
||||
break;
|
||||
case StringFeedbackClass:
|
||||
{
|
||||
|
@ -526,63 +480,46 @@ ProcXChangeFeedbackControl(ClientPtr client)
|
|||
if (client->swapped) {
|
||||
swaps(&f->num_keysyms, n);
|
||||
}
|
||||
if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (len != ((sizeof(xStringFeedbackCtl) >> 2) + f->num_keysyms))
|
||||
return BadLength;
|
||||
|
||||
for (s = dev->stringfeed; s; s = s->next)
|
||||
if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id) {
|
||||
ChangeStringFeedback(client, dev, stuff->mask, s,
|
||||
(xStringFeedbackCtl *) & stuff[1]);
|
||||
return Success;
|
||||
}
|
||||
if (s->ctrl.id == ((xStringFeedbackCtl *) & stuff[1])->id)
|
||||
return ChangeStringFeedback(client, dev, stuff->mask, s,
|
||||
(xStringFeedbackCtl *) & stuff[1]);
|
||||
break;
|
||||
}
|
||||
case IntegerFeedbackClass:
|
||||
if (len != (sizeof(xIntegerFeedbackCtl) >> 2)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (len != (sizeof(xIntegerFeedbackCtl) >> 2))
|
||||
return BadLength;
|
||||
|
||||
for (i = dev->intfeed; i; i = i->next)
|
||||
if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id) {
|
||||
ChangeIntegerFeedback(client, dev, stuff->mask, i,
|
||||
(xIntegerFeedbackCtl *) & stuff[1]);
|
||||
return Success;
|
||||
}
|
||||
if (i->ctrl.id == ((xIntegerFeedbackCtl *) & stuff[1])->id)
|
||||
return ChangeIntegerFeedback(client, dev, stuff->mask, i,
|
||||
(xIntegerFeedbackCtl *)&stuff[1]);
|
||||
break;
|
||||
case LedFeedbackClass:
|
||||
if (len != (sizeof(xLedFeedbackCtl) >> 2)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (len != (sizeof(xLedFeedbackCtl) >> 2))
|
||||
return BadLength;
|
||||
|
||||
for (l = dev->leds; l; l = l->next)
|
||||
if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id) {
|
||||
ChangeLedFeedback(client, dev, stuff->mask, l,
|
||||
(xLedFeedbackCtl *) & stuff[1]);
|
||||
return Success;
|
||||
}
|
||||
if (l->ctrl.id == ((xLedFeedbackCtl *) & stuff[1])->id)
|
||||
return ChangeLedFeedback(client, dev, stuff->mask, l,
|
||||
(xLedFeedbackCtl *) & stuff[1]);
|
||||
break;
|
||||
case BellFeedbackClass:
|
||||
if (len != (sizeof(xBellFeedbackCtl) >> 2)) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl,
|
||||
0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (len != (sizeof(xBellFeedbackCtl) >> 2))
|
||||
return BadLength;
|
||||
|
||||
for (b = dev->bell; b; b = b->next)
|
||||
if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id) {
|
||||
ChangeBellFeedback(client, dev, stuff->mask, b,
|
||||
(xBellFeedbackCtl *) & stuff[1]);
|
||||
return Success;
|
||||
}
|
||||
if (b->ctrl.id == ((xBellFeedbackCtl *) & stuff[1])->id)
|
||||
return ChangeBellFeedback(client, dev, stuff->mask, b,
|
||||
(xBellFeedbackCtl *) & stuff[1]);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
SendErrorToClient(client, IReqCode, X_ChangeFeedbackControl, 0, BadMatch);
|
||||
return Success;
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
|
|
|
@ -56,14 +56,11 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "XIstubs.h"
|
||||
#include "globals.h"
|
||||
#include "extnsionst.h"
|
||||
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -98,10 +95,8 @@ SProcXChangeKeyboardDevice(ClientPtr client)
|
|||
int
|
||||
ProcXChangeKeyboardDevice(ClientPtr client)
|
||||
{
|
||||
REQUEST(xChangeKeyboardDeviceReq);
|
||||
/* REQUEST(xChangeKeyboardDeviceReq); */
|
||||
REQUEST_SIZE_MATCH(xChangeKeyboardDeviceReq);
|
||||
|
||||
SendErrorToClient(client, IReqCode, X_ChangeKeyboardDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
return BadDevice;
|
||||
}
|
||||
|
|
14
Xi/chgkmap.c
14
Xi/chgkmap.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -111,18 +108,13 @@ ProcXChangeDeviceKeyMapping(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xChangeDeviceKeyMappingReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceKeyMapping, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
len = stuff->length - (sizeof(xChangeDeviceKeyMappingReq) >> 2);
|
||||
|
||||
ret = ChangeKeyMapping(client, dev, len, DeviceMappingNotify,
|
||||
stuff->firstKeyCode, stuff->keyCodes,
|
||||
stuff->keySymsPerKeyCode, (KeySym *) & stuff[1]);
|
||||
|
||||
if (ret != Success)
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceKeyMapping, 0, ret);
|
||||
return Success;
|
||||
return ret;
|
||||
}
|
||||
|
|
36
Xi/chgprop.c
36
Xi/chgprop.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h"
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
|
||||
#include "exevents.h"
|
||||
|
@ -115,30 +112,22 @@ ProcXChangeDeviceDontPropagateList(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xChangeDeviceDontPropagateListReq);
|
||||
|
||||
if (stuff->length != (sizeof(xChangeDeviceDontPropagateListReq) >> 2) +
|
||||
stuff->count) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
|
||||
BadLength);
|
||||
return Success;
|
||||
}
|
||||
stuff->count)
|
||||
return BadLength;
|
||||
|
||||
rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
|
||||
if (rc != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
|
||||
rc);
|
||||
return Success;
|
||||
}
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
if (stuff->mode != AddToList && stuff->mode != DeleteFromList) {
|
||||
client->errorValue = stuff->window;
|
||||
SendErrorToClient(client, IReqCode, X_ChangeDeviceDontPropagateList, 0,
|
||||
BadMode);
|
||||
return Success;
|
||||
return BadMode;
|
||||
}
|
||||
|
||||
if (CreateMaskFromList(client, (XEventClass *) & stuff[1],
|
||||
stuff->count, tmp, NULL,
|
||||
X_ChangeDeviceDontPropagateList) != Success)
|
||||
return Success;
|
||||
if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
|
||||
stuff->count, tmp, NULL,
|
||||
X_ChangeDeviceDontPropagateList)) != Success)
|
||||
return rc;
|
||||
|
||||
others = wOtherInputMasks(pWin);
|
||||
if (!others && stuff->mode == DeleteFromList)
|
||||
|
@ -153,11 +142,8 @@ ProcXChangeDeviceDontPropagateList(ClientPtr client)
|
|||
tmp[i].mask |= others->dontPropagateMask[i];
|
||||
|
||||
if (DeviceEventSuppressForWindow(pWin, client, tmp[i].mask, i) !=
|
||||
Success) {
|
||||
SendErrorToClient(client, IReqCode,
|
||||
X_ChangeDeviceDontPropagateList, 0, BadClass);
|
||||
return Success;
|
||||
}
|
||||
Success)
|
||||
return BadClass;
|
||||
}
|
||||
|
||||
return Success;
|
||||
|
|
|
@ -56,8 +56,6 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
|
@ -65,7 +63,6 @@ SOFTWARE.
|
|||
#include "windowstr.h" /* window structure */
|
||||
#include "scrnintstr.h" /* screen structure */
|
||||
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
|
||||
#include "dixevents.h"
|
||||
|
@ -101,10 +98,8 @@ SProcXChangePointerDevice(ClientPtr client)
|
|||
int
|
||||
ProcXChangePointerDevice(ClientPtr client)
|
||||
{
|
||||
REQUEST(xChangePointerDeviceReq);
|
||||
/* REQUEST(xChangePointerDeviceReq); */
|
||||
REQUEST_SIZE_MATCH(xChangePointerDeviceReq);
|
||||
|
||||
SendErrorToClient(client, IReqCode, X_ChangePointerDevice, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
return BadDevice;
|
||||
}
|
||||
|
|
|
@ -56,15 +56,12 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include "scrnintstr.h" /* screen structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "XIstubs.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -151,10 +148,8 @@ ProcXCloseDevice(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xCloseDeviceReq);
|
||||
|
||||
d = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (d == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_CloseDevice, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (d == NULL)
|
||||
return BadDevice;
|
||||
|
||||
if (d->deviceGrab.grab && SameClient(d->deviceGrab.grab, client))
|
||||
(*d->deviceGrab.DeactivateGrab) (d); /* release active grab */
|
||||
|
|
18
Xi/devbell.c
18
Xi/devbell.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -108,14 +105,12 @@ ProcXDeviceBell(ClientPtr client)
|
|||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
client->errorValue = stuff->deviceid;
|
||||
SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadDevice);
|
||||
return Success;
|
||||
return BadDevice;
|
||||
}
|
||||
|
||||
if (stuff->percent < -100 || stuff->percent > 100) {
|
||||
client->errorValue = stuff->percent;
|
||||
SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
if (stuff->feedbackclass == KbdFeedbackClass) {
|
||||
for (k = dev->kbdfeed; k; k = k->next)
|
||||
|
@ -123,8 +118,7 @@ ProcXDeviceBell(ClientPtr client)
|
|||
break;
|
||||
if (!k) {
|
||||
client->errorValue = stuff->feedbackid;
|
||||
SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
base = k->ctrl.bell;
|
||||
proc = k->BellProc;
|
||||
|
@ -136,8 +130,7 @@ ProcXDeviceBell(ClientPtr client)
|
|||
break;
|
||||
if (!b) {
|
||||
client->errorValue = stuff->feedbackid;
|
||||
SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
base = b->ctrl.percent;
|
||||
proc = b->BellProc;
|
||||
|
@ -145,8 +138,7 @@ ProcXDeviceBell(ClientPtr client)
|
|||
class = BellFeedbackClass;
|
||||
} else {
|
||||
client->errorValue = stuff->feedbackclass;
|
||||
SendErrorToClient(client, IReqCode, X_DeviceBell, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
newpercent = (base * stuff->percent) / 100;
|
||||
if (stuff->percent < 0)
|
||||
|
|
|
@ -74,6 +74,10 @@ SOFTWARE.
|
|||
#include "dixgrabs.h" /* CreateGrab() */
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#ifdef XKB
|
||||
#include "xkbsrv.h"
|
||||
#endif
|
||||
|
||||
#define WID(w) ((w) ? ((w)->drawable.id) : 0)
|
||||
#define AllModifiersMask ( \
|
||||
ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | \
|
||||
|
@ -1005,7 +1009,7 @@ SetModifierMapping(ClientPtr client, DeviceIntPtr dev, int len, int rlen,
|
|||
}
|
||||
|
||||
void
|
||||
SendDeviceMappingNotify(CARD8 request,
|
||||
SendDeviceMappingNotify(ClientPtr client, CARD8 request,
|
||||
KeyCode firstKeyCode, CARD8 count, DeviceIntPtr dev)
|
||||
{
|
||||
xEvent event;
|
||||
|
@ -1020,6 +1024,11 @@ SendDeviceMappingNotify(CARD8 request,
|
|||
ev->count = count;
|
||||
}
|
||||
|
||||
#ifdef XKB
|
||||
if (request == MappingKeyboard || request == MappingModifier)
|
||||
XkbApplyMappingChange(dev, request, firstKeyCode, count, client);
|
||||
#endif
|
||||
|
||||
SendEventToAllWindows(dev, DeviceMappingNotifyMask, (xEvent *) ev, 1);
|
||||
}
|
||||
|
||||
|
@ -1055,7 +1064,7 @@ ChangeKeyMapping(ClientPtr client,
|
|||
keysyms.map = map;
|
||||
if (!SetKeySymsMap(&k->curKeySyms, &keysyms))
|
||||
return BadAlloc;
|
||||
SendDeviceMappingNotify(MappingKeyboard, firstKeyCode, keyCodes, dev);
|
||||
SendDeviceMappingNotify(client, MappingKeyboard, firstKeyCode, keyCodes, dev);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
|
|
|
@ -58,8 +58,6 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "inputstr.h"
|
||||
#include "gcstruct.h" /* pointer for extnsionst.h */
|
||||
#include "extnsionst.h" /* extension entry */
|
||||
|
@ -1209,6 +1207,7 @@ XInputExtensionInit(void)
|
|||
EventSwapVector[DeviceButtonStateNotify] = SEventIDispatch;
|
||||
EventSwapVector[DeviceMappingNotify] = SEventIDispatch;
|
||||
EventSwapVector[ChangeDeviceNotify] = SEventIDispatch;
|
||||
EventSwapVector[DevicePresenceNotify] = SEventIDispatch;
|
||||
EventSwapVector[DeviceEnterNotify] = SEventIDispatch;
|
||||
EventSwapVector[DeviceLeaveNotify] = SEventIDispatch;
|
||||
|
||||
|
|
18
Xi/getbmap.c
18
Xi/getbmap.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -106,18 +103,13 @@ ProcXGetDeviceButtonMapping(ClientPtr client)
|
|||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
b = dev->button;
|
||||
if (b == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceButtonMapping, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (b == NULL)
|
||||
return BadMatch;
|
||||
|
||||
rep.nElts = b->numButtons;
|
||||
rep.length = (rep.nElts + (4 - 1)) / 4;
|
||||
WriteReplyToClient(client, sizeof(xGetDeviceButtonMappingReply), &rep);
|
||||
|
|
39
Xi/getdctl.c
39
Xi/getdctl.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -250,10 +247,8 @@ ProcXGetDeviceControl(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xGetDeviceControlReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_GetDeviceControl;
|
||||
|
@ -262,29 +257,20 @@ ProcXGetDeviceControl(ClientPtr client)
|
|||
|
||||
switch (stuff->control) {
|
||||
case DEVICE_RESOLUTION:
|
||||
if (!dev->valuator) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (!dev->valuator)
|
||||
return BadMatch;
|
||||
total_length = sizeof(xDeviceResolutionState) +
|
||||
(3 * sizeof(int) * dev->valuator->numAxes);
|
||||
break;
|
||||
case DEVICE_ABS_CALIB:
|
||||
if (!dev->absolute) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (!dev->absolute)
|
||||
return BadMatch;
|
||||
|
||||
total_length = sizeof(xDeviceAbsCalibCtl);
|
||||
break;
|
||||
case DEVICE_ABS_AREA:
|
||||
if (!dev->absolute) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (!dev->absolute)
|
||||
return BadMatch;
|
||||
|
||||
total_length = sizeof(xDeviceAbsAreaCtl);
|
||||
break;
|
||||
|
@ -295,15 +281,12 @@ ProcXGetDeviceControl(ClientPtr client)
|
|||
total_length = sizeof(xDeviceEnableCtl);
|
||||
break;
|
||||
default:
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
|
||||
buf = (char *)xalloc(total_length);
|
||||
if (!buf) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceControl, 0, BadAlloc);
|
||||
return Success;
|
||||
}
|
||||
if (!buf)
|
||||
return BadAlloc;
|
||||
savbuf = buf;
|
||||
|
||||
switch (stuff->control) {
|
||||
|
|
21
Xi/getfctl.c
21
Xi/getfctl.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -308,10 +305,8 @@ ProcXGetFeedbackControl(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xGetFeedbackControlReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_GetFeedbackControl;
|
||||
|
@ -345,16 +340,12 @@ ProcXGetFeedbackControl(ClientPtr client)
|
|||
total_length += sizeof(xBellFeedbackState);
|
||||
}
|
||||
|
||||
if (total_length == 0) {
|
||||
SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (total_length == 0)
|
||||
return BadMatch;
|
||||
|
||||
buf = (char *)xalloc(total_length);
|
||||
if (!buf) {
|
||||
SendErrorToClient(client, IReqCode, X_GetFeedbackControl, 0, BadAlloc);
|
||||
return Success;
|
||||
}
|
||||
if (!buf)
|
||||
return BadAlloc;
|
||||
savbuf = buf;
|
||||
|
||||
for (k = dev->kbdfeed; k; k = k->next)
|
||||
|
|
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "windowstr.h" /* focus struct */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -101,10 +98,8 @@ ProcXGetDeviceFocus(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xGetDeviceFocusReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL || !dev->focus) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceFocus, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL || !dev->focus)
|
||||
return BadDevice;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_GetDeviceFocus;
|
||||
|
|
23
Xi/getkmap.c
23
Xi/getkmap.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "swaprep.h"
|
||||
|
@ -102,29 +99,21 @@ ProcXGetDeviceKeyMapping(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xGetDeviceKeyMappingReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
|
||||
if (dev->key == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
if (dev->key == NULL)
|
||||
return BadMatch;
|
||||
k = &dev->key->curKeySyms;
|
||||
|
||||
if ((stuff->firstKeyCode < k->minKeyCode) ||
|
||||
(stuff->firstKeyCode > k->maxKeyCode)) {
|
||||
client->errorValue = stuff->firstKeyCode;
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
|
||||
if (stuff->firstKeyCode + stuff->count > k->maxKeyCode + 1) {
|
||||
client->errorValue = stuff->count;
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceKeyMapping, 0, BadValue);
|
||||
return Success;
|
||||
return BadValue;
|
||||
}
|
||||
|
||||
rep.repType = X_Reply;
|
||||
|
|
18
Xi/getmmap.c
18
Xi/getmmap.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h> /* Request macro */
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -102,18 +99,13 @@ ProcXGetDeviceModifierMapping(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xGetDeviceModifierMappingReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceModifierMapping, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
kp = dev->key;
|
||||
if (kp == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceModifierMapping, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (kp == NULL)
|
||||
return BadMatch;
|
||||
|
||||
maxkeys = kp->maxKeysPerModifier;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
|
|
10
Xi/getprop.c
10
Xi/getprop.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structs */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "swaprep.h"
|
||||
|
@ -116,11 +113,8 @@ ProcXGetDeviceDontPropagateList(ClientPtr client)
|
|||
rep.count = 0;
|
||||
|
||||
rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
|
||||
if (rc != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceDontPropagateList, 0,
|
||||
rc);
|
||||
return Success;
|
||||
}
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
if ((others = wOtherInputMasks(pWin)) != 0) {
|
||||
for (i = 0; i < EMASKSIZE; i++)
|
||||
|
|
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window struct */
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "swaprep.h"
|
||||
|
@ -118,11 +115,8 @@ ProcXGetSelectedExtensionEvents(ClientPtr client)
|
|||
rep.all_clients_count = 0;
|
||||
|
||||
rc = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
|
||||
if (rc != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_GetSelectedExtensionEvents, 0,
|
||||
rc);
|
||||
return Success;
|
||||
}
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
if ((pOthers = wOtherInputMasks(pWin)) != 0) {
|
||||
for (others = pOthers->inputClients; others; others = others->next)
|
||||
|
|
10
Xi/getvers.c
10
Xi/getvers.c
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -102,11 +99,8 @@ ProcXGetExtensionVersion(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xGetExtensionVersionReq);
|
||||
|
||||
if (stuff->length != (sizeof(xGetExtensionVersionReq) +
|
||||
stuff->nbytes + 3) >> 2) {
|
||||
SendErrorToClient(client, IReqCode, X_GetExtensionVersion, 0,
|
||||
BadLength);
|
||||
return Success;
|
||||
}
|
||||
stuff->nbytes + 3) >> 2)
|
||||
return BadLength;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_GetExtensionVersion;
|
||||
|
|
49
Xi/grabdev.c
49
Xi/grabdev.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "dixevents.h" /* GrabDevice */
|
||||
|
@ -109,7 +106,7 @@ SProcXGrabDevice(ClientPtr client)
|
|||
int
|
||||
ProcXGrabDevice(ClientPtr client)
|
||||
{
|
||||
int error;
|
||||
int rc;
|
||||
xGrabDeviceReply rep;
|
||||
DeviceIntPtr dev;
|
||||
struct tmask tmp[EMASKSIZE];
|
||||
|
@ -117,10 +114,8 @@ ProcXGrabDevice(ClientPtr client)
|
|||
REQUEST(xGrabDeviceReq);
|
||||
REQUEST_AT_LEAST_SIZE(xGrabDeviceReq);
|
||||
|
||||
if (stuff->length != (sizeof(xGrabDeviceReq) >> 2) + stuff->event_count) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (stuff->length != (sizeof(xGrabDeviceReq) >> 2) + stuff->event_count)
|
||||
return BadLength;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_GrabDevice;
|
||||
|
@ -128,25 +123,22 @@ ProcXGrabDevice(ClientPtr client)
|
|||
rep.length = 0;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDevice, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
if (CreateMaskFromList(client, (XEventClass *) & stuff[1],
|
||||
stuff->event_count, tmp, dev,
|
||||
X_GrabDevice) != Success)
|
||||
return Success;
|
||||
if ((rc = CreateMaskFromList(client, (XEventClass *) & stuff[1],
|
||||
stuff->event_count, tmp, dev,
|
||||
X_GrabDevice)) != Success)
|
||||
return rc;
|
||||
|
||||
error = GrabDevice(client, dev, stuff->this_device_mode,
|
||||
stuff->other_devices_mode, stuff->grabWindow,
|
||||
stuff->ownerEvents, stuff->time,
|
||||
tmp[stuff->deviceid].mask, &rep.status, FALSE);
|
||||
rc = GrabDevice(client, dev, stuff->this_device_mode,
|
||||
stuff->other_devices_mode, stuff->grabWindow,
|
||||
stuff->ownerEvents, stuff->time,
|
||||
tmp[stuff->deviceid].mask, &rep.status, FALSE);
|
||||
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
if (error != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDevice, 0, error);
|
||||
return Success;
|
||||
}
|
||||
WriteReplyToClient(client, sizeof(xGrabDeviceReply), &rep);
|
||||
return Success;
|
||||
}
|
||||
|
@ -190,15 +182,12 @@ CreateMaskFromList(ClientPtr client, XEventClass * list, int count,
|
|||
|
||||
for (i = 0; i < count; i++, list++) {
|
||||
device = *list >> 8;
|
||||
if (device > 255) { /* FIXME: we only use 7 bit for devices? */
|
||||
SendErrorToClient(client, IReqCode, req, 0, BadClass);
|
||||
if (device > 255) /* FIXME: we only use 7 bit for devices? */
|
||||
return BadClass;
|
||||
}
|
||||
|
||||
tdev = LookupDeviceIntRec(device);
|
||||
if (tdev == NULL || (dev != NULL && tdev != dev)) {
|
||||
SendErrorToClient(client, IReqCode, req, 0, BadClass);
|
||||
if (tdev == NULL || (dev != NULL && tdev != dev))
|
||||
return BadClass;
|
||||
}
|
||||
|
||||
for (j = 0; j < ExtEventIndex; j++)
|
||||
if (EventInfo[j].type == (*list & 0xff)) {
|
||||
|
|
|
@ -56,14 +56,11 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "exevents.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -117,28 +114,19 @@ ProcXGrabDeviceButton(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xGrabDeviceButtonReq);
|
||||
|
||||
if (stuff->length !=
|
||||
(sizeof(xGrabDeviceButtonReq) >> 2) + stuff->event_count) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
(sizeof(xGrabDeviceButtonReq) >> 2) + stuff->event_count)
|
||||
return BadLength;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->grabbed_device);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
if (stuff->modifier_device != UseXKeyboard) {
|
||||
mdev = LookupDeviceIntRec(stuff->modifier_device);
|
||||
if (mdev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (mdev->key == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (mdev == NULL)
|
||||
return BadDevice;
|
||||
if (mdev->key == NULL)
|
||||
return BadMatch;
|
||||
} else
|
||||
mdev = PickKeyboard(client);
|
||||
|
||||
|
@ -147,13 +135,11 @@ ProcXGrabDeviceButton(ClientPtr client)
|
|||
if ((ret = CreateMaskFromList(client, class,
|
||||
stuff->event_count, tmp, dev,
|
||||
X_GrabDeviceButton)) != Success)
|
||||
return Success;
|
||||
return ret;
|
||||
ret = GrabButton(client, dev, stuff->this_device_mode,
|
||||
stuff->other_devices_mode, stuff->modifiers, mdev,
|
||||
stuff->button, stuff->grabWindow, stuff->ownerEvents,
|
||||
(Cursor) 0, (Window) 0, tmp[stuff->grabbed_device].mask);
|
||||
|
||||
if (ret != Success)
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceButton, 0, ret);
|
||||
return (Success);
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -56,14 +56,11 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "exevents.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -115,27 +112,19 @@ ProcXGrabDeviceKey(ClientPtr client)
|
|||
REQUEST(xGrabDeviceKeyReq);
|
||||
REQUEST_AT_LEAST_SIZE(xGrabDeviceKeyReq);
|
||||
|
||||
if (stuff->length != (sizeof(xGrabDeviceKeyReq) >> 2) + stuff->event_count) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (stuff->length != (sizeof(xGrabDeviceKeyReq) >> 2) + stuff->event_count)
|
||||
return BadLength;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->grabbed_device);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
if (stuff->modifier_device != UseXKeyboard) {
|
||||
mdev = LookupDeviceIntRec(stuff->modifier_device);
|
||||
if (mdev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (mdev->key == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (mdev == NULL)
|
||||
return BadDevice;
|
||||
if (mdev->key == NULL)
|
||||
return BadMatch;
|
||||
} else
|
||||
mdev = PickKeyboard(client);
|
||||
|
||||
|
@ -144,17 +133,12 @@ ProcXGrabDeviceKey(ClientPtr client)
|
|||
if ((ret = CreateMaskFromList(client, class,
|
||||
stuff->event_count, tmp, dev,
|
||||
X_GrabDeviceKey)) != Success)
|
||||
return Success;
|
||||
return ret;
|
||||
|
||||
ret = GrabKey(client, dev, stuff->this_device_mode,
|
||||
stuff->other_devices_mode, stuff->modifiers, mdev,
|
||||
stuff->key, stuff->grabWindow, stuff->ownerEvents,
|
||||
tmp[stuff->grabbed_device].mask);
|
||||
|
||||
if (ret != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_GrabDeviceKey, 0, ret);
|
||||
return Success;
|
||||
}
|
||||
|
||||
return Success;
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -110,17 +107,11 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
|
|||
|
||||
REQUEST_SIZE_MATCH(xGetDeviceMotionEventsReq);
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
v = dev->valuator;
|
||||
if (v == NULL || v->numAxes == 0) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (v == NULL || v->numAxes == 0)
|
||||
return BadMatch;
|
||||
if (dev->valuator->motionHintWindow)
|
||||
MaybeStopDeviceHint(dev, client);
|
||||
axes = v->numAxes;
|
||||
|
@ -144,12 +135,9 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
|
|||
if (num_events) {
|
||||
size = sizeof(Time) + (axes * sizeof(INT32));
|
||||
tsize = num_events * size;
|
||||
coords = (INT32 *) ALLOCATE_LOCAL(tsize);
|
||||
if (!coords) {
|
||||
SendErrorToClient(client, IReqCode, X_GetDeviceMotionEvents, 0,
|
||||
BadAlloc);
|
||||
return Success;
|
||||
}
|
||||
coords = (INT32 *) xalloc(tsize);
|
||||
if (!coords)
|
||||
return BadAlloc;
|
||||
rep.nEvents = (v->GetMotionProc) (dev, (xTimecoord *) coords, /* XXX */
|
||||
start.milliseconds, stop.milliseconds,
|
||||
(ScreenPtr) NULL);
|
||||
|
@ -173,7 +161,7 @@ ProcXGetDeviceMotionEvents(ClientPtr client)
|
|||
WriteToClient(client, length * 4, (char *)coords);
|
||||
}
|
||||
if (coords)
|
||||
DEALLOCATE_LOCAL(coords);
|
||||
xfree(coords);
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
|
15
Xi/opendev.c
15
Xi/opendev.c
|
@ -56,14 +56,11 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "XIstubs.h"
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -110,17 +107,13 @@ ProcXOpenDevice(ClientPtr client)
|
|||
for (dev = inputInfo.off_devices; dev; dev = dev->next)
|
||||
if (dev->id == stuff->deviceid)
|
||||
break;
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_OpenDevice, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
}
|
||||
|
||||
OpenInputDevice(dev, client, &status);
|
||||
if (status != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_OpenDevice, 0, status);
|
||||
return Success;
|
||||
}
|
||||
if (status != Success)
|
||||
return status;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_OpenDevice;
|
||||
|
|
15
Xi/queryst.c
15
Xi/queryst.c
|
@ -38,13 +38,10 @@ from The Open Group.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -100,10 +97,8 @@ ProcXQueryDeviceState(ClientPtr client)
|
|||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
v = dev->valuator;
|
||||
if (v != NULL && v->motionHintWindow != NULL)
|
||||
|
@ -126,10 +121,8 @@ ProcXQueryDeviceState(ClientPtr client)
|
|||
num_classes++;
|
||||
}
|
||||
buf = (char *)xalloc(total_length);
|
||||
if (!buf) {
|
||||
SendErrorToClient(client, IReqCode, X_QueryDeviceState, 0, BadAlloc);
|
||||
return Success;
|
||||
}
|
||||
if (!buf)
|
||||
return BadAlloc;
|
||||
savbuf = buf;
|
||||
|
||||
if (k != NULL) {
|
||||
|
|
|
@ -57,13 +57,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -164,40 +161,29 @@ ProcXSelectExtensionEvent(ClientPtr client)
|
|||
REQUEST(xSelectExtensionEventReq);
|
||||
REQUEST_AT_LEAST_SIZE(xSelectExtensionEventReq);
|
||||
|
||||
if (stuff->length != (sizeof(xSelectExtensionEventReq) >> 2) + stuff->count) {
|
||||
SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
|
||||
BadLength);
|
||||
return Success;
|
||||
}
|
||||
if (stuff->length != (sizeof(xSelectExtensionEventReq) >> 2) + stuff->count)
|
||||
return BadLength;
|
||||
|
||||
ret = dixLookupWindow(&pWin, stuff->window, client, DixUnknownAccess);
|
||||
if (ret != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0, ret);
|
||||
return Success;
|
||||
}
|
||||
if (ret != Success)
|
||||
return ret;
|
||||
|
||||
if (HandleDevicePresenceMask(client, pWin, (XEventClass *) & stuff[1],
|
||||
&stuff->count) != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
|
||||
BadAlloc);
|
||||
return Success;
|
||||
}
|
||||
&stuff->count) != Success)
|
||||
return BadAlloc;
|
||||
|
||||
if ((ret = CreateMaskFromList(client, (XEventClass *) & stuff[1],
|
||||
stuff->count, tmp, NULL,
|
||||
X_SelectExtensionEvent)) != Success)
|
||||
return Success;
|
||||
return ret;
|
||||
|
||||
for (i = 0; i < EMASKSIZE; i++)
|
||||
if (tmp[i].dev != NULL) {
|
||||
if ((ret =
|
||||
SelectForWindow((DeviceIntPtr) tmp[i].dev, pWin, client,
|
||||
tmp[i].mask, ExtExclusiveMasks[i],
|
||||
ExtValidMasks[i])) != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_SelectExtensionEvent, 0,
|
||||
ret);
|
||||
return Success;
|
||||
}
|
||||
ExtValidMasks[i])) != Success)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return Success;
|
||||
|
|
|
@ -57,13 +57,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* Window */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exevents.h"
|
||||
#include "exglobals.h"
|
||||
|
@ -131,38 +128,29 @@ ProcXSendExtensionEvent(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
|
||||
|
||||
if (stuff->length != (sizeof(xSendExtensionEventReq) >> 2) + stuff->count +
|
||||
(stuff->num_events * (sizeof(xEvent) >> 2))) {
|
||||
SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
(stuff->num_events * (sizeof(xEvent) >> 2)))
|
||||
return BadLength;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
/* The client's event type must be one defined by an extension. */
|
||||
|
||||
first = ((xEvent *) & stuff[1]);
|
||||
if (!((EXTENSION_EVENT_BASE <= first->u.u.type) &&
|
||||
(first->u.u.type < lastEvent))) {
|
||||
(first->u.u.type < lastEvent)))
|
||||
client->errorValue = first->u.u.type;
|
||||
SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, BadValue);
|
||||
return Success;
|
||||
}
|
||||
return BadValue;
|
||||
|
||||
list = (XEventClass *) (first + stuff->num_events);
|
||||
if ((ret = CreateMaskFromList(client, list, stuff->count, tmp, dev,
|
||||
X_SendExtensionEvent)) != Success)
|
||||
return Success;
|
||||
return ret;
|
||||
|
||||
ret = (SendEvent(client, dev, stuff->destination,
|
||||
stuff->propagate, (xEvent *) & stuff[1],
|
||||
tmp[stuff->deviceid].mask, stuff->num_events));
|
||||
|
||||
if (ret != Success)
|
||||
SendErrorToClient(client, IReqCode, X_SendExtensionEvent, 0, ret);
|
||||
|
||||
return Success;
|
||||
return ret;
|
||||
}
|
||||
|
|
26
Xi/setbmap.c
26
Xi/setbmap.c
|
@ -59,13 +59,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "exevents.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -104,11 +101,8 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xSetDeviceButtonMappingReq);
|
||||
|
||||
if (stuff->length != (sizeof(xSetDeviceButtonMappingReq) +
|
||||
stuff->map_length + 3) >> 2) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0,
|
||||
BadLength);
|
||||
return Success;
|
||||
}
|
||||
stuff->map_length + 3) >> 2)
|
||||
return BadLength;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_SetDeviceButtonMapping;
|
||||
|
@ -117,24 +111,20 @@ ProcXSetDeviceButtonMapping(ClientPtr client)
|
|||
rep.status = MappingSuccess;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
ret = SetButtonMapping(client, dev, stuff->map_length, (BYTE *) & stuff[1]);
|
||||
|
||||
if (ret == BadValue || ret == BadMatch) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceButtonMapping, 0, ret);
|
||||
return Success;
|
||||
} else {
|
||||
if (ret == BadValue || ret == BadMatch)
|
||||
return ret;
|
||||
else {
|
||||
rep.status = ret;
|
||||
WriteReplyToClient(client, sizeof(xSetDeviceButtonMappingReply), &rep);
|
||||
}
|
||||
|
||||
if (ret != MappingBusy)
|
||||
SendDeviceMappingNotify(MappingPointer, 0, 0, dev);
|
||||
SendDeviceMappingNotify(client, MappingPointer, 0, 0, dev);
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
|
36
Xi/setdval.c
36
Xi/setdval.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "XIstubs.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -106,24 +103,17 @@ ProcXSetDeviceValuators(ClientPtr client)
|
|||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
if (stuff->length != (sizeof(xSetDeviceValuatorsReq) >> 2) +
|
||||
stuff->num_valuators) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadLength);
|
||||
return Success;
|
||||
}
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev->valuator == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
stuff->num_valuators)
|
||||
return BadLength;
|
||||
|
||||
if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0, BadValue);
|
||||
return Success;
|
||||
}
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
if (dev->valuator == NULL)
|
||||
return BadMatch;
|
||||
|
||||
if (stuff->first_valuator + stuff->num_valuators > dev->valuator->numAxes)
|
||||
return BadValue;
|
||||
|
||||
if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client))
|
||||
rep.status = AlreadyGrabbed;
|
||||
|
@ -133,11 +123,9 @@ ProcXSetDeviceValuators(ClientPtr client)
|
|||
stuff->num_valuators);
|
||||
|
||||
if (rep.status != Success && rep.status != AlreadyGrabbed)
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceValuators, 0,
|
||||
rep.status);
|
||||
else
|
||||
WriteReplyToClient(client, sizeof(xSetDeviceValuatorsReply), &rep);
|
||||
return rep.status;
|
||||
|
||||
WriteReplyToClient(client, sizeof(xSetDeviceValuatorsReply), &rep);
|
||||
return Success;
|
||||
}
|
||||
|
||||
|
|
|
@ -56,8 +56,6 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "windowstr.h" /* focus struct */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
|
@ -65,7 +63,6 @@ SOFTWARE.
|
|||
|
||||
#include "dixevents.h"
|
||||
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -106,15 +103,11 @@ ProcXSetDeviceFocus(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xSetDeviceFocusReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->device);
|
||||
if (dev == NULL || !dev->focus) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL || !dev->focus)
|
||||
return BadDevice;
|
||||
|
||||
ret = SetInputFocus(client, dev, stuff->focus, stuff->revertTo,
|
||||
stuff->time, TRUE);
|
||||
if (ret != Success)
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceFocus, 0, ret);
|
||||
|
||||
return Success;
|
||||
return ret;
|
||||
}
|
||||
|
|
19
Xi/setmmap.c
19
Xi/setmmap.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "exevents.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -103,11 +100,8 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
|
|||
REQUEST_AT_LEAST_SIZE(xSetDeviceModifierMappingReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
|
||||
rep.repType = X_Reply;
|
||||
rep.RepType = X_SetDeviceModifierMapping;
|
||||
|
@ -122,14 +116,11 @@ ProcXSetDeviceModifierMapping(ClientPtr client)
|
|||
if (ret == MappingSuccess || ret == MappingBusy || ret == MappingFailed) {
|
||||
rep.success = ret;
|
||||
if (ret == MappingSuccess)
|
||||
SendDeviceMappingNotify(MappingModifier, 0, 0, dev);
|
||||
SendDeviceMappingNotify(client, MappingModifier, 0, 0, dev);
|
||||
WriteReplyToClient(client, sizeof(xSetDeviceModifierMappingReply),
|
||||
&rep);
|
||||
} else {
|
||||
if (ret == -1)
|
||||
ret = BadValue;
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceModifierMapping, 0, ret);
|
||||
}
|
||||
} else if (ret == -1)
|
||||
return BadValue;
|
||||
|
||||
return Success;
|
||||
}
|
||||
|
|
21
Xi/setmode.c
21
Xi/setmode.c
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "XIstubs.h"
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -105,14 +102,10 @@ ProcXSetDeviceMode(ClientPtr client)
|
|||
rep.sequenceNumber = client->sequence;
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev->valuator == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
if (dev->valuator == NULL)
|
||||
return BadMatch;
|
||||
if ((dev->deviceGrab.grab) && !SameClient(dev->deviceGrab.grab, client))
|
||||
rep.status = AlreadyGrabbed;
|
||||
else
|
||||
|
@ -120,10 +113,8 @@ ProcXSetDeviceMode(ClientPtr client)
|
|||
|
||||
if (rep.status == Success)
|
||||
dev->valuator->mode = stuff->mode;
|
||||
else if (rep.status != AlreadyGrabbed) {
|
||||
SendErrorToClient(client, IReqCode, X_SetDeviceMode, 0, rep.status);
|
||||
return Success;
|
||||
}
|
||||
else if (rep.status != AlreadyGrabbed)
|
||||
return rep.status;
|
||||
|
||||
WriteReplyToClient(client, sizeof(xSetDeviceModeReply), &rep);
|
||||
return Success;
|
||||
|
|
|
@ -56,12 +56,9 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
|
||||
|
@ -102,10 +99,8 @@ ProcXUngrabDevice(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xUngrabDeviceReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->deviceid);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDevice, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
grab = dev->deviceGrab.grab;
|
||||
|
||||
time = ClientTimeToServerTime(stuff->time);
|
||||
|
|
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "dixgrabs.h"
|
||||
|
@ -111,41 +108,27 @@ ProcXUngrabDeviceButton(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xUngrabDeviceButtonReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->grabbed_device);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev->button == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
if (dev->button == NULL)
|
||||
return BadMatch;
|
||||
|
||||
if (stuff->modifier_device != UseXKeyboard) {
|
||||
mdev = LookupDeviceIntRec(stuff->modifier_device);
|
||||
if (mdev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (mdev->key == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0,
|
||||
BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (mdev == NULL)
|
||||
return BadDevice;
|
||||
if (mdev->key == NULL)
|
||||
return BadMatch;
|
||||
} else
|
||||
mdev = PickKeyboard(client);
|
||||
|
||||
rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixUnknownAccess);
|
||||
if (rc != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, rc);
|
||||
return Success;
|
||||
}
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
if ((stuff->modifiers != AnyModifier) &&
|
||||
(stuff->modifiers & ~AllModifiersMask)) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceButton, 0, BadValue);
|
||||
return Success;
|
||||
}
|
||||
(stuff->modifiers & ~AllModifiersMask))
|
||||
return BadValue;
|
||||
|
||||
temporaryGrab.resource = client->clientAsMask;
|
||||
temporaryGrab.device = dev;
|
||||
|
|
|
@ -56,13 +56,10 @@ SOFTWARE.
|
|||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h> /* for inputstr.h */
|
||||
#include <X11/Xproto.h> /* Request macro */
|
||||
#include "inputstr.h" /* DeviceIntPtr */
|
||||
#include "windowstr.h" /* window structure */
|
||||
#include <X11/extensions/XI.h>
|
||||
#include <X11/extensions/XIproto.h>
|
||||
#include "extnsionst.h"
|
||||
#include "extinit.h" /* LookupDeviceIntRec */
|
||||
#include "exglobals.h"
|
||||
#include "dixgrabs.h"
|
||||
|
@ -111,45 +108,32 @@ ProcXUngrabDeviceKey(ClientPtr client)
|
|||
REQUEST_SIZE_MATCH(xUngrabDeviceKeyReq);
|
||||
|
||||
dev = LookupDeviceIntRec(stuff->grabbed_device);
|
||||
if (dev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (dev->key == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (dev == NULL)
|
||||
return BadDevice;
|
||||
if (dev->key == NULL)
|
||||
return BadMatch;
|
||||
|
||||
if (stuff->modifier_device != UseXKeyboard) {
|
||||
mdev = LookupDeviceIntRec(stuff->modifier_device);
|
||||
if (mdev == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0,
|
||||
BadDevice);
|
||||
return Success;
|
||||
}
|
||||
if (mdev->key == NULL) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadMatch);
|
||||
return Success;
|
||||
}
|
||||
if (mdev == NULL)
|
||||
return BadDevice;
|
||||
if (mdev->key == NULL)
|
||||
return BadMatch;
|
||||
} else
|
||||
mdev = PickKeyboard(client);
|
||||
|
||||
rc = dixLookupWindow(&pWin, stuff->grabWindow, client, DixUnknownAccess);
|
||||
if (rc != Success) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, rc);
|
||||
return Success;
|
||||
}
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
if (((stuff->key > dev->key->curKeySyms.maxKeyCode) ||
|
||||
(stuff->key < dev->key->curKeySyms.minKeyCode))
|
||||
&& (stuff->key != AnyKey)) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue);
|
||||
return Success;
|
||||
}
|
||||
&& (stuff->key != AnyKey))
|
||||
return BadValue;
|
||||
|
||||
if ((stuff->modifiers != AnyModifier) &&
|
||||
(stuff->modifiers & ~AllModifiersMask)) {
|
||||
SendErrorToClient(client, IReqCode, X_UngrabDeviceKey, 0, BadValue);
|
||||
return Success;
|
||||
}
|
||||
(stuff->modifiers & ~AllModifiersMask))
|
||||
return BadValue;
|
||||
|
||||
temporaryGrab.resource = client->clientAsMask;
|
||||
temporaryGrab.device = dev;
|
||||
|
|
|
@ -6,11 +6,11 @@ libafb_gen_sources = afbbltC.c afbbltX.c afbbltCI.c afbbltO.c afbbltG.c afbtileC
|
|||
|
||||
DISTCLEANFILES = $(libafb_gen_sources)
|
||||
|
||||
libafb_la_SOURCES = afbgc.c afbwindow.c afbfont.c afbfillrct.c afbpntwin.c afbpixmap.c \
|
||||
libafb_la_SOURCES = afbgc.c afbwindow.c afbfont.c afbfillrct.c afbpixmap.c \
|
||||
afbimage.c afbline.c afbbres.c afbhrzvert.c afbbresd.c afbpushpxl.c afbply1rct.c \
|
||||
afbzerarc.c afbfillarc.c afbfillsp.c afbsetsp.c afbscrinit.c afbplygblt.c \
|
||||
afbclip.c afbgetsp.c afbpolypnt.c afbbitblt.c afbcmap.c afbimggblt.c afbpntarea.c \
|
||||
afbmisc.c afbbstore.c afbtegblt.c $(libafb_gen_sources)
|
||||
afbmisc.c afbtegblt.c $(libafb_gen_sources)
|
||||
|
||||
INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/hw/xfree86/os-support
|
||||
|
||||
|
|
34
afb/afb.h
34
afb/afb.h
|
@ -182,23 +182,7 @@ extern void afbBresD(
|
|||
unsigned char * /*rrops*/,
|
||||
unsigned char * /*bgrrops*/
|
||||
);
|
||||
/* afbbstore.c */
|
||||
|
||||
extern void afbSaveAreas(
|
||||
PixmapPtr /*pPixmap*/,
|
||||
RegionPtr /*prgnSave*/,
|
||||
int /*xorg*/,
|
||||
int /*yorg*/,
|
||||
WindowPtr /*pWin*/
|
||||
);
|
||||
|
||||
extern void afbRestoreAreas(
|
||||
PixmapPtr /*pPixmap*/,
|
||||
RegionPtr /*prgnRestore*/,
|
||||
int /*xorg*/,
|
||||
int /*yorg*/,
|
||||
WindowPtr /*pWin*/
|
||||
);
|
||||
/* afbclip.c */
|
||||
|
||||
extern RegionPtr afbPixmapToRegion(
|
||||
|
@ -499,7 +483,8 @@ extern PixmapPtr afbCreatePixmap(
|
|||
ScreenPtr /*pScreen*/,
|
||||
int /*width*/,
|
||||
int /*height*/,
|
||||
int /*depth*/
|
||||
int /*depth*/,
|
||||
unsigned /*usage_hint*/
|
||||
);
|
||||
|
||||
extern Bool afbDestroyPixmap(
|
||||
|
@ -522,11 +507,6 @@ extern void afbCopyRotatePixmap(
|
|||
int /*xrot*/,
|
||||
int /*yrot*/
|
||||
);
|
||||
extern void afbPaintWindow(
|
||||
WindowPtr /*pWin*/,
|
||||
RegionPtr /*pRegion*/,
|
||||
int /*what*/
|
||||
);
|
||||
/* afbpolypnt.c */
|
||||
|
||||
extern void afbPolyPoint(
|
||||
|
@ -760,16 +740,6 @@ extern int frameWindowPrivateIndex; /* index into Window private array */
|
|||
#define afbGetGCPrivate(pGC) \
|
||||
((afbPrivGC *)((pGC)->devPrivates[afbGCPrivateIndex].ptr))
|
||||
|
||||
/* private field of window */
|
||||
typedef struct {
|
||||
unsigned char fastBorder; /* non-zero if border tile is 32 bits wide */
|
||||
unsigned char fastBackground;
|
||||
unsigned short unused; /* pad for alignment with Sun compiler */
|
||||
DDXPointRec oldRotate;
|
||||
PixmapPtr pRotatedBackground;
|
||||
PixmapPtr pRotatedBorder;
|
||||
} afbPrivWin;
|
||||
|
||||
/* Common macros for extracting drawing information */
|
||||
|
||||
#define afbGetTypedWidth(pDrawable,wtype)( \
|
||||
|
|
|
@ -279,7 +279,7 @@ afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable,
|
|||
/* Do bit blitting */
|
||||
numRects = REGION_NUM_RECTS(&rgnDst);
|
||||
if (numRects && width && height) {
|
||||
if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
|
||||
if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
|
||||
sizeof(DDXPointRec)))) {
|
||||
REGION_UNINIT(pGC->pScreen, &rgnDst);
|
||||
if (freeSrcClip)
|
||||
|
@ -296,7 +296,7 @@ afbBitBlt(register DrawablePtr pSrcDrawable, register DrawablePtr pDstDrawable,
|
|||
(*doBitBlt)(pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc,
|
||||
planemask);
|
||||
|
||||
DEALLOCATE_LOCAL(pptSrc);
|
||||
xfree(pptSrc);
|
||||
}
|
||||
|
||||
prgnExposed = NULL;
|
||||
|
|
26
afb/afbblt.c
26
afb/afbblt.c
|
@ -132,12 +132,12 @@ MROP_NAME(afbDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
|
|||
|
||||
if (nbox > 1) {
|
||||
/* keep ordering in each band, reverse order of bands */
|
||||
pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec)*nbox);
|
||||
pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec)*nbox);
|
||||
if(!pboxNew1)
|
||||
return;
|
||||
pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec)*nbox);
|
||||
pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec)*nbox);
|
||||
if(!pptNew1) {
|
||||
DEALLOCATE_LOCAL(pboxNew1);
|
||||
xfree(pboxNew1);
|
||||
return;
|
||||
}
|
||||
pboxBase = pboxNext = pbox+nbox-1;
|
||||
|
@ -169,16 +169,16 @@ MROP_NAME(afbDoBitblt)(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
|
|||
|
||||
if (nbox > 1) {
|
||||
/* reverse order of rects in each band */
|
||||
pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
|
||||
pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
|
||||
pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pboxNew2 || !pptNew2) {
|
||||
if (pptNew2)
|
||||
DEALLOCATE_LOCAL(pptNew2);
|
||||
xfree(pptNew2);
|
||||
if (pboxNew2)
|
||||
DEALLOCATE_LOCAL(pboxNew2);
|
||||
xfree(pboxNew2);
|
||||
if (pboxNew1) {
|
||||
DEALLOCATE_LOCAL(pptNew1);
|
||||
DEALLOCATE_LOCAL(pboxNew1);
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
@ -553,11 +553,11 @@ bits1 = *--psrc; --pdst; \
|
|||
pptSrc++;
|
||||
}
|
||||
if (pboxNew2) {
|
||||
DEALLOCATE_LOCAL(pptNew2);
|
||||
DEALLOCATE_LOCAL(pboxNew2);
|
||||
xfree(pptNew2);
|
||||
xfree(pboxNew2);
|
||||
}
|
||||
if (pboxNew1) {
|
||||
DEALLOCATE_LOCAL(pptNew1);
|
||||
DEALLOCATE_LOCAL(pboxNew1);
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
}
|
||||
|
|
154
afb/afbbstore.c
154
afb/afbbstore.c
|
@ -1,154 +0,0 @@
|
|||
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
|
||||
/*
|
||||
|
||||
Copyright (c) 1987 X Consortium
|
||||
|
||||
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 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 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 NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE X CONSORTIUM 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.
|
||||
|
||||
Except as contained in this notice, the name of the X Consortium shall
|
||||
not be used in advertising or otherwise to promote the sale, use or
|
||||
other dealings in this Software without prior written authorization
|
||||
from the X Consortium.
|
||||
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include "afb.h"
|
||||
#include <X11/X.h>
|
||||
#include "mibstore.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "windowstr.h"
|
||||
|
||||
/*-
|
||||
*-----------------------------------------------------------------------
|
||||
* afbSaveAreas --
|
||||
* Function called by miSaveAreas to actually fetch the areas to be
|
||||
* saved into the backing pixmap. This is very simple to do, since
|
||||
* afbDoBitblt is designed for this very thing. The region to save is
|
||||
* already destination-relative and we're given the offset to the
|
||||
* window origin, so we have only to create an array of points of the
|
||||
* u.l. corners of the boxes in the region translated to the screen
|
||||
* coordinate system and fetch the screen pixmap out of its devPrivate
|
||||
* field....
|
||||
*
|
||||
* Results:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* Data are copied from the screen into the pixmap.
|
||||
*
|
||||
*-----------------------------------------------------------------------
|
||||
*/
|
||||
void
|
||||
afbSaveAreas(pPixmap, prgnSave, xorg, yorg, pWin)
|
||||
PixmapPtr pPixmap; /* Backing pixmap */
|
||||
RegionPtr prgnSave; /* Region to save (pixmap-relative) */
|
||||
int xorg; /* X origin of region */
|
||||
int yorg; /* Y origin of region */
|
||||
WindowPtr pWin;
|
||||
{
|
||||
register DDXPointPtr pPt;
|
||||
DDXPointPtr pPtsInit;
|
||||
register BoxPtr pBox;
|
||||
register int numRects;
|
||||
|
||||
numRects = REGION_NUM_RECTS(prgnSave);
|
||||
pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(numRects * sizeof(DDXPointRec));
|
||||
if (!pPtsInit)
|
||||
return;
|
||||
|
||||
pBox = REGION_RECTS(prgnSave);
|
||||
pPt = pPtsInit;
|
||||
while (numRects--) {
|
||||
pPt->x = pBox->x1 + xorg;
|
||||
pPt->y = pBox->y1 + yorg;
|
||||
pPt++;
|
||||
pBox++;
|
||||
}
|
||||
|
||||
afbDoBitblt((DrawablePtr)pPixmap->drawable.pScreen->devPrivates[afbScreenPrivateIndex].ptr,
|
||||
(DrawablePtr)pPixmap,
|
||||
GXcopy,
|
||||
prgnSave,
|
||||
pPtsInit, wBackingBitPlanes (pWin));
|
||||
|
||||
DEALLOCATE_LOCAL(pPtsInit);
|
||||
}
|
||||
|
||||
/*-
|
||||
*-----------------------------------------------------------------------
|
||||
* afbRestoreAreas --
|
||||
* Function called by miRestoreAreas to actually fetch the areas to be
|
||||
* restored from the backing pixmap. This is very simple to do, since
|
||||
* afbDoBitblt is designed for this very thing. The region to restore is
|
||||
* already destination-relative and we're given the offset to the
|
||||
* window origin, so we have only to create an array of points of the
|
||||
* u.l. corners of the boxes in the region translated to the pixmap
|
||||
* coordinate system and fetch the screen pixmap out of its devPrivate
|
||||
* field....
|
||||
*
|
||||
* Results:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* Data are copied from the pixmap into the screen.
|
||||
*
|
||||
*-----------------------------------------------------------------------
|
||||
*/
|
||||
void
|
||||
afbRestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin)
|
||||
PixmapPtr pPixmap; /* Backing pixmap */
|
||||
RegionPtr prgnRestore; /* Region to restore (screen-relative)*/
|
||||
int xorg; /* X origin of window */
|
||||
int yorg; /* Y origin of window */
|
||||
WindowPtr pWin;
|
||||
{
|
||||
register DDXPointPtr pPt;
|
||||
DDXPointPtr pPtsInit;
|
||||
register BoxPtr pBox;
|
||||
register int numRects;
|
||||
|
||||
numRects = REGION_NUM_RECTS(prgnRestore);
|
||||
pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(numRects*sizeof(DDXPointRec));
|
||||
if (!pPtsInit)
|
||||
return;
|
||||
|
||||
pBox = REGION_RECTS(prgnRestore);
|
||||
pPt = pPtsInit;
|
||||
while (numRects--) {
|
||||
pPt->x = pBox->x1 - xorg;
|
||||
pPt->y = pBox->y1 - yorg;
|
||||
pPt++;
|
||||
pBox++;
|
||||
}
|
||||
|
||||
afbDoBitblt((DrawablePtr)pPixmap,
|
||||
(DrawablePtr)pPixmap->drawable.pScreen->devPrivates[afbScreenPrivateIndex].ptr,
|
||||
GXcopy,
|
||||
prgnRestore,
|
||||
pPtsInit, wBackingBitPlanes (pWin));
|
||||
|
||||
DEALLOCATE_LOCAL(pPtsInit);
|
||||
}
|
|
@ -111,7 +111,7 @@ afbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *pre
|
|||
|
||||
numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
|
||||
if (numRects > NUM_STACK_RECTS) {
|
||||
pboxClippedBase = (BoxPtr)ALLOCATE_LOCAL(numRects * sizeof(BoxRec));
|
||||
pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
|
||||
if (!pboxClippedBase)
|
||||
return;
|
||||
}
|
||||
|
@ -287,5 +287,5 @@ afbPolyFillRect(DrawablePtr pDrawable, GCPtr pGC, int nrectFill, xRectangle *pre
|
|||
}
|
||||
}
|
||||
if (pboxClippedBase != stackRects)
|
||||
DEALLOCATE_LOCAL(pboxClippedBase);
|
||||
xfree(pboxClippedBase);
|
||||
}
|
||||
|
|
|
@ -109,11 +109,11 @@ afbSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
unsigned char *rrops;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -183,8 +183,8 @@ afbSolidFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
pwidth++;
|
||||
ppt++;
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -219,11 +219,11 @@ afbStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
unsigned char *rrops;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -297,8 +297,8 @@ afbStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
pwidth++;
|
||||
ppt++;
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -333,11 +333,11 @@ afbTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
int d;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -428,8 +428,8 @@ afbTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
break;
|
||||
}
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -465,11 +465,11 @@ afbOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
int d;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -587,8 +587,8 @@ afbOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
break;
|
||||
}
|
||||
} /* switch (rop) */
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
/* Fill spans with tiles that aren't PPW bits wide */
|
||||
|
@ -626,11 +626,11 @@ afbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
register int d;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -732,8 +732,8 @@ afbUnnaturalTileFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
/* Fill spans with stipples that aren't PPW bits wide */
|
||||
|
@ -772,11 +772,11 @@ afbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
int depthDst;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -877,8 +877,8 @@ afbUnnaturalStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
/* Fill spans with OpaqueStipples that aren't PPW bits wide */
|
||||
|
@ -918,11 +918,11 @@ afbUnnaturalOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
int depthDst;
|
||||
|
||||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree) {
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -1124,6 +1124,6 @@ afbUnnaturalOpaqueStippleFS(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
|
|
@ -72,7 +72,8 @@ afbPutImage(pDraw, pGC, depth, x, y, width, height, leftPad, format, pImage)
|
|||
int depthDst;
|
||||
|
||||
/* Create a tmp pixmap */
|
||||
pPixmap = (pScreen->CreatePixmap)(pScreen, width, height, depth);
|
||||
pPixmap = (pScreen->CreatePixmap)(pScreen, width, height, depth,
|
||||
CREATE_PIXMAP_USAGE_SCRATCH);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
|
||||
|
|
|
@ -298,7 +298,7 @@ afbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
|||
int getWidth; /* bits to get from glyph */
|
||||
#endif
|
||||
|
||||
if(!(ppos = (afbTEXTPOS *)ALLOCATE_LOCAL(nglyph * sizeof(afbTEXTPOS))))
|
||||
if(!(ppos = (afbTEXTPOS *)xalloc(nglyph * sizeof(afbTEXTPOS))))
|
||||
return;
|
||||
|
||||
pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
|
||||
|
@ -462,7 +462,7 @@ afbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
|||
} /* depth */
|
||||
} /* for each glyph */
|
||||
} /* while nbox-- */
|
||||
DEALLOCATE_LOCAL(ppos);
|
||||
xfree(ppos);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
@ -70,11 +70,12 @@ SOFTWARE.
|
|||
#include "mfb.h"
|
||||
|
||||
PixmapPtr
|
||||
afbCreatePixmap(pScreen, width, height, depth)
|
||||
afbCreatePixmap(pScreen, width, height, depth, usage_hint)
|
||||
ScreenPtr pScreen;
|
||||
int width;
|
||||
int height;
|
||||
int depth;
|
||||
unsigned usage_hint;
|
||||
{
|
||||
PixmapPtr pPixmap;
|
||||
size_t datasize;
|
||||
|
@ -127,8 +128,10 @@ afbCopyPixmap(PixmapPtr pSrc)
|
|||
|
||||
size = pSrc->drawable.height * pSrc->devKind * pSrc->drawable.depth;
|
||||
pScreen = pSrc->drawable.pScreen;
|
||||
pDst = (*pScreen->CreatePixmap)(pScreen, pSrc->drawable.width,
|
||||
pSrc->drawable.height, pSrc->drawable.depth);
|
||||
pDst = (*pScreen->CreatePixmap)(pScreen,
|
||||
pSrc->drawable.width,
|
||||
pSrc->drawable.height,
|
||||
pSrc->drawable.depth, 0);
|
||||
if (!pDst)
|
||||
return(NullPixmap);
|
||||
memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
|
||||
|
@ -248,7 +251,7 @@ afbYRotatePixmap(pPix, rh)
|
|||
nbyDown = rh * pPix->devKind;
|
||||
nbyUp = (pPix->devKind * height) - nbyDown;
|
||||
|
||||
if(!(ptmp = (char *)ALLOCATE_LOCAL(nbyUp)))
|
||||
if(!(ptmp = (char *)xalloc(nbyUp)))
|
||||
return;
|
||||
|
||||
for (d = 0; d < pPix->drawable.depth; d++) {
|
||||
|
@ -258,7 +261,7 @@ afbYRotatePixmap(pPix, rh)
|
|||
memmove(pbase, pbase+nbyUp, nbyDown); /* slide the top rows down */
|
||||
memmove(pbase+nbyDown, ptmp, nbyUp); /* move lower rows up to row rh */
|
||||
}
|
||||
DEALLOCATE_LOCAL(ptmp);
|
||||
xfree(ptmp);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
@ -278,7 +278,7 @@ afbPolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
|||
int getWidth; /* bits to get from glyph */
|
||||
#endif
|
||||
|
||||
if(!(ppos = (afbTEXTPOS *)ALLOCATE_LOCAL(nglyph * sizeof(afbTEXTPOS))))
|
||||
if(!(ppos = (afbTEXTPOS *)xalloc(nglyph * sizeof(afbTEXTPOS))))
|
||||
return;
|
||||
|
||||
pdstBase = afbScanlineNoBankSwitch(pdstBase, x, y, widthDst);
|
||||
|
@ -453,7 +453,7 @@ afbPolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
|||
} /* depth */
|
||||
} /* for each glyph */
|
||||
} /* while nbox-- */
|
||||
DEALLOCATE_LOCAL(ppos);
|
||||
xfree(ppos);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
126
afb/afbpntwin.c
126
afb/afbpntwin.c
|
@ -1,126 +0,0 @@
|
|||
/* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
|
||||
/***********************************************************
|
||||
|
||||
Copyright (c) 1987 X Consortium
|
||||
|
||||
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 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
X CONSORTIUM 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.
|
||||
|
||||
Except as contained in this notice, the name of the X Consortium shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from the X Consortium.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "windowstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "afb.h"
|
||||
#include "maskbits.h"
|
||||
#include "mi.h"
|
||||
|
||||
void
|
||||
afbPaintWindow(pWin, pRegion, what)
|
||||
WindowPtr pWin;
|
||||
RegionPtr pRegion;
|
||||
int what;
|
||||
{
|
||||
register afbPrivWin *pPrivWin;
|
||||
unsigned char rrops[AFB_MAX_DEPTH];
|
||||
|
||||
pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
|
||||
|
||||
switch (what) {
|
||||
case PW_BACKGROUND:
|
||||
switch (pWin->backgroundState) {
|
||||
case None:
|
||||
return;
|
||||
case ParentRelative:
|
||||
do {
|
||||
pWin = pWin->parent;
|
||||
} while (pWin->backgroundState == ParentRelative);
|
||||
(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
|
||||
what);
|
||||
return;
|
||||
case BackgroundPixmap:
|
||||
if (pPrivWin->fastBackground) {
|
||||
afbTileAreaPPWCopy((DrawablePtr)pWin,
|
||||
REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion), GXcopy,
|
||||
pPrivWin->pRotatedBackground, ~0);
|
||||
return;
|
||||
} else {
|
||||
afbTileAreaCopy((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion), GXcopy,
|
||||
pWin->background.pixmap, 0, 0, ~0);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case BackgroundPixel:
|
||||
afbReduceRop(GXcopy, pWin->background.pixel, ~0,
|
||||
pWin->drawable.depth, rrops);
|
||||
afbSolidFillArea((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion), rrops);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case PW_BORDER:
|
||||
if (pWin->borderIsPixel) {
|
||||
afbReduceRop(GXcopy, pWin->border.pixel, ~0, pWin->drawable.depth,
|
||||
rrops);
|
||||
afbSolidFillArea((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion), rrops);
|
||||
return;
|
||||
} else if (pPrivWin->fastBorder) {
|
||||
afbTileAreaPPWCopy((DrawablePtr)pWin, REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion), GXcopy,
|
||||
pPrivWin->pRotatedBorder, ~0);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
}
|
||||
miPaintWindow(pWin, pRegion, what);
|
||||
}
|
|
@ -71,20 +71,11 @@ SOFTWARE.
|
|||
#ifdef PIXMAP_PER_WINDOW
|
||||
int frameWindowPrivateIndex;
|
||||
#endif
|
||||
int afbWindowPrivateIndex;
|
||||
int afbGCPrivateIndex;
|
||||
int afbScreenPrivateIndex;
|
||||
|
||||
static unsigned long afbGeneration = 0;
|
||||
|
||||
static BSFuncRec afbBSFuncRec = {
|
||||
afbSaveAreas,
|
||||
afbRestoreAreas,
|
||||
(BackingStoreSetClipmaskRgnProcPtr) 0,
|
||||
(BackingStoreGetImagePixmapProcPtr) 0,
|
||||
(BackingStoreGetSpansPixmapProcPtr) 0,
|
||||
};
|
||||
|
||||
static Bool
|
||||
afbCloseScreen(int index, ScreenPtr pScreen)
|
||||
{
|
||||
|
@ -148,20 +139,16 @@ afbAllocatePrivates(ScreenPtr pScreen, int *pWinIndex, int *pGCIndex)
|
|||
#ifdef PIXMAP_PER_WINDOW
|
||||
frameWindowPrivateIndex = AllocateWindowPrivateIndex();
|
||||
#endif
|
||||
afbWindowPrivateIndex = AllocateWindowPrivateIndex();
|
||||
afbGCPrivateIndex = AllocateGCPrivateIndex();
|
||||
afbGeneration = serverGeneration;
|
||||
}
|
||||
if (pWinIndex)
|
||||
*pWinIndex = afbWindowPrivateIndex;
|
||||
if (pGCIndex)
|
||||
*pGCIndex = afbGCPrivateIndex;
|
||||
|
||||
afbScreenPrivateIndex = AllocateScreenPrivateIndex();
|
||||
pScreen->GetWindowPixmap = afbGetWindowPixmap;
|
||||
pScreen->SetWindowPixmap = afbSetWindowPixmap;
|
||||
return(AllocateWindowPrivate(pScreen, afbWindowPrivateIndex, sizeof(afbPrivWin)) &&
|
||||
AllocateGCPrivate(pScreen, afbGCPrivateIndex, sizeof(afbPrivGC)));
|
||||
return(AllocateGCPrivate(pScreen, afbGCPrivateIndex, sizeof(afbPrivGC)));
|
||||
}
|
||||
|
||||
/* dts * (inch/dot) * (25.4 mm / inch) = mm */
|
||||
|
@ -206,8 +193,6 @@ afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, i
|
|||
pScreen->ChangeWindowAttributes = afbChangeWindowAttributes;
|
||||
pScreen->RealizeWindow = afbMapWindow;
|
||||
pScreen->UnrealizeWindow = afbUnmapWindow;
|
||||
pScreen->PaintWindowBackground = afbPaintWindow;
|
||||
pScreen->PaintWindowBorder = afbPaintWindow;
|
||||
pScreen->CopyWindow = afbCopyWindow;
|
||||
pScreen->CreatePixmap = afbCreatePixmap;
|
||||
pScreen->DestroyPixmap = afbDestroyPixmap;
|
||||
|
@ -231,7 +216,6 @@ afbScreenInit(register ScreenPtr pScreen, pointer pbits, int xsize, int ysize, i
|
|||
|
||||
pScreen->CloseScreen = afbCloseScreen;
|
||||
pScreen->CreateScreenResources = afbCreateScreenResources;
|
||||
pScreen->BackingStoreFuncs = afbBSFuncRec;
|
||||
|
||||
pScreen->devPrivates[afbScreenPrivateIndex].ptr = pScreen->devPrivate;
|
||||
pScreen->devPrivate = oldDevPrivate;
|
||||
|
|
167
afb/afbwindow.c
167
afb/afbwindow.c
|
@ -62,39 +62,16 @@ SOFTWARE.
|
|||
#include "maskbits.h"
|
||||
|
||||
Bool
|
||||
afbCreateWindow(pWin)
|
||||
register WindowPtr pWin;
|
||||
afbCreateWindow(WindowPtr pWin)
|
||||
{
|
||||
register afbPrivWin *pPrivWin;
|
||||
|
||||
pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
|
||||
pPrivWin->pRotatedBorder = NullPixmap;
|
||||
pPrivWin->pRotatedBackground = NullPixmap;
|
||||
pPrivWin->fastBackground = FALSE;
|
||||
pPrivWin->fastBorder = FALSE;
|
||||
#ifdef PIXMAP_PER_WINDOW
|
||||
pWin->devPrivates[frameWindowPrivateIndex].ptr =
|
||||
pWin->pDrawable.pScreen->devPrivates[afbScreenPrivateIndex].ptr;
|
||||
#endif
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/* This always returns true, because Xfree can't fail. It might be possible
|
||||
* on some devices for Destroy to fail */
|
||||
Bool
|
||||
afbDestroyWindow(pWin)
|
||||
WindowPtr pWin;
|
||||
afbDestroyWindow(WindowPtr pWin)
|
||||
{
|
||||
register afbPrivWin *pPrivWin;
|
||||
|
||||
pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
|
||||
|
||||
if (pPrivWin->pRotatedBorder)
|
||||
(*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBorder);
|
||||
if (pPrivWin->pRotatedBackground)
|
||||
(*pWin->drawable.pScreen->DestroyPixmap)(pPrivWin->pRotatedBackground);
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
|
@ -106,46 +83,10 @@ afbMapWindow(pWindow)
|
|||
return (TRUE);
|
||||
}
|
||||
|
||||
/* (x, y) is the upper left corner of the window on the screen
|
||||
do we really need to pass this? (is it a;ready in pWin->absCorner?)
|
||||
we only do the rotation for pixmaps that are 32 bits wide (padded
|
||||
or otherwise.)
|
||||
afbChangeWindowAttributes() has already put a copy of the pixmap
|
||||
in pPrivWin->pRotated*
|
||||
*/
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
afbPositionWindow(pWin, x, y)
|
||||
WindowPtr pWin;
|
||||
int x, y;
|
||||
afbPositionWindow(WindowPtr pWin, int x, int y)
|
||||
{
|
||||
register afbPrivWin *pPrivWin;
|
||||
int reset = 0;
|
||||
|
||||
pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
|
||||
if (pWin->backgroundState == BackgroundPixmap && pPrivWin->fastBackground) {
|
||||
afbXRotatePixmap(pPrivWin->pRotatedBackground,
|
||||
pWin->drawable.x - pPrivWin->oldRotate.x);
|
||||
afbYRotatePixmap(pPrivWin->pRotatedBackground,
|
||||
pWin->drawable.y - pPrivWin->oldRotate.y);
|
||||
reset = 1;
|
||||
}
|
||||
|
||||
if (!pWin->borderIsPixel && pPrivWin->fastBorder) {
|
||||
while (pWin->backgroundState == ParentRelative)
|
||||
pWin = pWin->parent;
|
||||
afbXRotatePixmap(pPrivWin->pRotatedBorder,
|
||||
pWin->drawable.x - pPrivWin->oldRotate.x);
|
||||
afbYRotatePixmap(pPrivWin->pRotatedBorder,
|
||||
pWin->drawable.y - pPrivWin->oldRotate.y);
|
||||
reset = 1;
|
||||
}
|
||||
if (reset) {
|
||||
pPrivWin->oldRotate.x = pWin->drawable.x;
|
||||
pPrivWin->oldRotate.y = pWin->drawable.y;
|
||||
}
|
||||
|
||||
/* This is the "wrong" fix to the right problem, but it doesn't really
|
||||
* cost very much. When the window is moved, we need to invalidate any
|
||||
* RotatedPixmap that exists in any GC currently validated against this
|
||||
|
@ -200,7 +141,7 @@ afbCopyWindow(pWin, ptOldOrg, prgnSrc)
|
|||
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
if(!(pptSrc = (DDXPointPtr )ALLOCATE_LOCAL(nbox * sizeof(DDXPointRec))))
|
||||
if(!(pptSrc = (DDXPointPtr )xalloc(nbox * sizeof(DDXPointRec))))
|
||||
return;
|
||||
ppt = pptSrc;
|
||||
|
||||
|
@ -211,108 +152,12 @@ afbCopyWindow(pWin, ptOldOrg, prgnSrc)
|
|||
|
||||
afbDoBitblt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot, GXcopy, prgnDst,
|
||||
pptSrc, ~0);
|
||||
DEALLOCATE_LOCAL(pptSrc);
|
||||
xfree(pptSrc);
|
||||
REGION_DESTROY(pWin->drawable.pScreen, prgnDst);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* swap in correct PaintWindow* routine. If we can use a fast output
|
||||
routine (i.e. the pixmap is paddable to 32 bits), also pre-rotate a copy
|
||||
of it in devPrivate.
|
||||
*/
|
||||
Bool
|
||||
afbChangeWindowAttributes(pWin, mask)
|
||||
register WindowPtr pWin;
|
||||
register unsigned long mask;
|
||||
afbChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
|
||||
{
|
||||
register unsigned long index;
|
||||
register afbPrivWin *pPrivWin;
|
||||
WindowPtr pBgWin;
|
||||
|
||||
pPrivWin = (afbPrivWin *)(pWin->devPrivates[afbWindowPrivateIndex].ptr);
|
||||
/*
|
||||
* When background state changes from ParentRelative and
|
||||
* we had previously rotated the fast border pixmap to match
|
||||
* the parent relative origin, rerotate to match window
|
||||
*/
|
||||
if (mask & (CWBackPixmap | CWBackPixel) &&
|
||||
pWin->backgroundState != ParentRelative && pPrivWin->fastBorder &&
|
||||
(pPrivWin->oldRotate.x != pWin->drawable.x ||
|
||||
pPrivWin->oldRotate.y != pWin->drawable.y)) {
|
||||
afbXRotatePixmap(pPrivWin->pRotatedBorder,
|
||||
pWin->drawable.x - pPrivWin->oldRotate.x);
|
||||
afbYRotatePixmap(pPrivWin->pRotatedBorder,
|
||||
pWin->drawable.y - pPrivWin->oldRotate.y);
|
||||
pPrivWin->oldRotate.x = pWin->drawable.x;
|
||||
pPrivWin->oldRotate.y = pWin->drawable.y;
|
||||
}
|
||||
while(mask) {
|
||||
index = lowbit (mask);
|
||||
mask &= ~index;
|
||||
switch(index) {
|
||||
case CWBackPixmap:
|
||||
if (pWin->backgroundState == None)
|
||||
pPrivWin->fastBackground = FALSE;
|
||||
else if (pWin->backgroundState == ParentRelative) {
|
||||
pPrivWin->fastBackground = FALSE;
|
||||
/* Rotate border to match parent origin */
|
||||
if (pPrivWin->pRotatedBorder) {
|
||||
for (pBgWin = pWin->parent;
|
||||
pBgWin->backgroundState == ParentRelative;
|
||||
pBgWin = pBgWin->parent);
|
||||
afbXRotatePixmap(pPrivWin->pRotatedBorder,
|
||||
pBgWin->drawable.x - pPrivWin->oldRotate.x);
|
||||
afbYRotatePixmap(pPrivWin->pRotatedBorder,
|
||||
pBgWin->drawable.y - pPrivWin->oldRotate.y);
|
||||
pPrivWin->oldRotate.x = pBgWin->drawable.x;
|
||||
pPrivWin->oldRotate.y = pBgWin->drawable.y;
|
||||
}
|
||||
} else if ((pWin->background.pixmap->drawable.width <= PPW) &&
|
||||
!(pWin->background.pixmap->drawable.width &
|
||||
(pWin->background.pixmap->drawable.width - 1))) {
|
||||
afbCopyRotatePixmap(pWin->background.pixmap,
|
||||
&pPrivWin->pRotatedBackground,
|
||||
pWin->drawable.x, pWin->drawable.y);
|
||||
if (pPrivWin->pRotatedBackground) {
|
||||
pPrivWin->fastBackground = TRUE;
|
||||
pPrivWin->oldRotate.x = pWin->drawable.x;
|
||||
pPrivWin->oldRotate.y = pWin->drawable.y;
|
||||
} else
|
||||
pPrivWin->fastBackground = FALSE;
|
||||
} else
|
||||
pPrivWin->fastBackground = FALSE;
|
||||
break;
|
||||
|
||||
case CWBackPixel:
|
||||
pPrivWin->fastBackground = FALSE;
|
||||
break;
|
||||
|
||||
case CWBorderPixmap:
|
||||
if ((pWin->border.pixmap->drawable.width <= PPW) &&
|
||||
!(pWin->border.pixmap->drawable.width &
|
||||
(pWin->border.pixmap->drawable.width - 1))) {
|
||||
for (pBgWin = pWin;
|
||||
pBgWin->backgroundState == ParentRelative;
|
||||
pBgWin = pBgWin->parent);
|
||||
afbCopyRotatePixmap(pWin->border.pixmap,
|
||||
&pPrivWin->pRotatedBorder,
|
||||
pBgWin->drawable.x, pBgWin->drawable.y);
|
||||
if (pPrivWin->pRotatedBorder) {
|
||||
pPrivWin->fastBorder = TRUE;
|
||||
pPrivWin->oldRotate.x = pBgWin->drawable.x;
|
||||
pPrivWin->oldRotate.y = pBgWin->drawable.y;
|
||||
} else
|
||||
pPrivWin->fastBorder = FALSE;
|
||||
} else
|
||||
pPrivWin->fastBorder = FALSE;
|
||||
break;
|
||||
case CWBorderPixel:
|
||||
pPrivWin->fastBorder = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* Again, we have no failure modes indicated by any of the routines
|
||||
* we've called, so we have to assume it worked */
|
||||
return (TRUE);
|
||||
}
|
||||
|
|
|
@ -8,14 +8,14 @@ DISTCLEANFILES = $(libcfb_gen_sources)
|
|||
CFB_INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/cfb
|
||||
|
||||
libcfb_common_sources = $(top_srcdir)/cfb/cfbgc.c $(top_srcdir)/cfb/cfbrrop.c \
|
||||
$(top_srcdir)/cfb/cfbwindow.c $(top_srcdir)/cfb/cfbpntwin.c \
|
||||
$(top_srcdir)/cfb/cfbwindow.c \
|
||||
$(top_srcdir)/cfb/cfbmskbits.c $(top_srcdir)/cfb/cfbpixmap.c \
|
||||
$(top_srcdir)/cfb/cfbbitblt.c $(top_srcdir)/cfb/cfbfillsp.c \
|
||||
$(top_srcdir)/cfb/cfbsetsp.c $(top_srcdir)/cfb/cfbscrinit.c \
|
||||
$(top_srcdir)/cfb/cfballpriv.c $(top_srcdir)/cfb/cfbgetsp.c \
|
||||
$(top_srcdir)/cfb/cfbfillrct.c $(top_srcdir)/cfb/cfbigblt8.c \
|
||||
$(top_srcdir)/cfb/cfbglblt8.c $(top_srcdir)/cfb/cfbtegblt.c \
|
||||
$(top_srcdir)/cfb/cfbbstore.c $(top_srcdir)/cfb/cfbpolypnt.c \
|
||||
$(top_srcdir)/cfb/cfbpolypnt.c \
|
||||
$(top_srcdir)/cfb/cfbbres.c $(top_srcdir)/cfb/cfbline.c \
|
||||
$(top_srcdir)/cfb/cfbhrzvert.c $(top_srcdir)/cfb/cfbbresd.c \
|
||||
$(top_srcdir)/cfb/cfbimage.c $(top_srcdir)/cfb/cfbcppl.c \
|
||||
|
|
56
cfb/cfb.h
56
cfb/cfb.h
|
@ -56,7 +56,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
*/
|
||||
|
||||
extern int cfbGCPrivateIndex;
|
||||
extern int cfbWindowPrivateIndex;
|
||||
|
||||
/* private field of GC */
|
||||
typedef struct {
|
||||
|
@ -81,20 +80,6 @@ typedef struct {
|
|||
CfbBits xor, and;
|
||||
} cfbRRopRec, *cfbRRopPtr;
|
||||
|
||||
/* private field of window */
|
||||
typedef struct {
|
||||
unsigned char fastBorder; /* non-zero if border is 32 bits wide */
|
||||
unsigned char fastBackground;
|
||||
unsigned short unused; /* pad for alignment with Sun compiler */
|
||||
DDXPointRec oldRotate;
|
||||
PixmapPtr pRotatedBackground;
|
||||
PixmapPtr pRotatedBorder;
|
||||
} cfbPrivWin;
|
||||
|
||||
#define cfbGetWindowPrivate(_pWin) ((cfbPrivWin *)\
|
||||
(_pWin)->devPrivates[cfbWindowPrivateIndex].ptr)
|
||||
|
||||
|
||||
/* cfb8bit.c */
|
||||
|
||||
extern int cfbSetStipple(
|
||||
|
@ -313,7 +298,6 @@ extern int cfb8SegmentSS1RectXor(
|
|||
|
||||
extern Bool cfbAllocatePrivates(
|
||||
ScreenPtr /*pScreen*/,
|
||||
int * /*window_index*/,
|
||||
int * /*gc_index*/
|
||||
);
|
||||
/* cfbbitblt.c */
|
||||
|
@ -486,23 +470,7 @@ extern void cfbBresD(
|
|||
int /*e2*/,
|
||||
int /*len*/
|
||||
);
|
||||
/* cfbbstore.c */
|
||||
|
||||
extern void cfbSaveAreas(
|
||||
PixmapPtr /*pPixmap*/,
|
||||
RegionPtr /*prgnSave*/,
|
||||
int /*xorg*/,
|
||||
int /*yorg*/,
|
||||
WindowPtr /*pWin*/
|
||||
);
|
||||
|
||||
extern void cfbRestoreAreas(
|
||||
PixmapPtr /*pPixmap*/,
|
||||
RegionPtr /*prgnRestore*/,
|
||||
int /*xorg*/,
|
||||
int /*yorg*/,
|
||||
WindowPtr /*pWin*/
|
||||
);
|
||||
/* cfbcmap.c */
|
||||
|
||||
#ifndef CFB_PROTOTYPES_ONLY
|
||||
|
@ -771,7 +739,8 @@ extern PixmapPtr cfbCreatePixmap(
|
|||
ScreenPtr /*pScreen*/,
|
||||
int /*width*/,
|
||||
int /*height*/,
|
||||
int /*depth*/
|
||||
int /*depth*/,
|
||||
unsigned /*usage_hint*/
|
||||
);
|
||||
|
||||
extern Bool cfbDestroyPixmap(
|
||||
|
@ -822,27 +791,6 @@ extern void cfbFillPoly1RectGeneral(
|
|||
int /*count*/,
|
||||
DDXPointPtr /*ptsIn*/
|
||||
);
|
||||
/* cfbpntwin.c */
|
||||
|
||||
extern void cfbPaintWindow(
|
||||
WindowPtr /*pWin*/,
|
||||
RegionPtr /*pRegion*/,
|
||||
int /*what*/
|
||||
);
|
||||
|
||||
extern void cfbFillBoxSolid(
|
||||
DrawablePtr /*pDrawable*/,
|
||||
int /*nBox*/,
|
||||
BoxPtr /*pBox*/,
|
||||
unsigned long /*pixel*/
|
||||
);
|
||||
|
||||
extern void cfbFillBoxTile32(
|
||||
DrawablePtr /*pDrawable*/,
|
||||
int /*nBox*/,
|
||||
BoxPtr /*pBox*/,
|
||||
PixmapPtr /*tile*/
|
||||
);
|
||||
/* cfbpolypnt.c */
|
||||
|
||||
extern void cfbPolyPoint(
|
||||
|
|
|
@ -45,7 +45,6 @@ in this Software without prior written authorization from The Open Group.
|
|||
#include "mibstore.h"
|
||||
|
||||
#if 1 || PSZ==8
|
||||
int cfbWindowPrivateIndex = -1;
|
||||
int cfbGCPrivateIndex = -1;
|
||||
#endif
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
|
@ -55,29 +54,20 @@ static unsigned long cfbGeneration = 0;
|
|||
|
||||
|
||||
Bool
|
||||
cfbAllocatePrivates(pScreen, window_index, gc_index)
|
||||
ScreenPtr pScreen;
|
||||
int *window_index, *gc_index;
|
||||
cfbAllocatePrivates(ScreenPtr pScreen, int *gc_index)
|
||||
{
|
||||
if (!window_index || !gc_index ||
|
||||
(*window_index == -1 && *gc_index == -1))
|
||||
if (!gc_index || *gc_index == -1)
|
||||
{
|
||||
if (!mfbAllocatePrivates(pScreen,
|
||||
&cfbWindowPrivateIndex, &cfbGCPrivateIndex))
|
||||
if (!mfbAllocatePrivates(pScreen, &cfbGCPrivateIndex))
|
||||
return FALSE;
|
||||
if (window_index)
|
||||
*window_index = cfbWindowPrivateIndex;
|
||||
if (gc_index)
|
||||
*gc_index = cfbGCPrivateIndex;
|
||||
}
|
||||
else
|
||||
{
|
||||
cfbWindowPrivateIndex = *window_index;
|
||||
cfbGCPrivateIndex = *gc_index;
|
||||
}
|
||||
if (!AllocateWindowPrivate(pScreen, cfbWindowPrivateIndex,
|
||||
sizeof(cfbPrivWin)) ||
|
||||
!AllocateGCPrivate(pScreen, cfbGCPrivateIndex, sizeof(cfbPrivGC)))
|
||||
if (!AllocateGCPrivate(pScreen, cfbGCPrivateIndex, sizeof(cfbPrivGC)))
|
||||
return FALSE;
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
if (cfbGeneration != serverGeneration)
|
||||
|
|
|
@ -296,7 +296,7 @@ cfbBitBlt (
|
|||
numRects = REGION_NUM_RECTS(&rgnDst);
|
||||
if (numRects && width && height)
|
||||
{
|
||||
if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
|
||||
if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
|
||||
sizeof(DDXPointRec))))
|
||||
{
|
||||
REGION_UNINIT(pGC->pScreen, &rgnDst);
|
||||
|
@ -313,7 +313,7 @@ cfbBitBlt (
|
|||
}
|
||||
|
||||
(*doBitBlt) (pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc, pGC->planemask);
|
||||
DEALLOCATE_LOCAL(pptSrc);
|
||||
xfree(pptSrc);
|
||||
}
|
||||
|
||||
prgnExposed = NULL;
|
||||
|
@ -559,7 +559,7 @@ cfbCopyPlaneReduce (
|
|||
numRects = REGION_NUM_RECTS(&rgnDst);
|
||||
if (numRects && width && height)
|
||||
{
|
||||
if(!(pptSrc = (DDXPointPtr)ALLOCATE_LOCAL(numRects *
|
||||
if(!(pptSrc = (DDXPointPtr)xalloc(numRects *
|
||||
sizeof(DDXPointRec))))
|
||||
{
|
||||
REGION_UNINIT(pGC->pScreen, &rgnDst);
|
||||
|
@ -576,7 +576,7 @@ cfbCopyPlaneReduce (
|
|||
}
|
||||
|
||||
(*doCopyPlane) (pSrcDrawable, pDstDrawable, pGC->alu, &rgnDst, pptSrc, pGC->planemask, bitPlane);
|
||||
DEALLOCATE_LOCAL(pptSrc);
|
||||
xfree(pptSrc);
|
||||
}
|
||||
|
||||
prgnExposed = NULL;
|
||||
|
@ -1407,7 +1407,8 @@ RegionPtr cfbCopyPlane(pSrcDrawable, pDstDrawable,
|
|||
ScreenPtr pScreen = pSrcDrawable->pScreen;
|
||||
GCPtr pGC1;
|
||||
|
||||
pBitmap = (*pScreen->CreatePixmap) (pScreen, width, height, 1);
|
||||
pBitmap = (*pScreen->CreatePixmap) (pScreen, width, height, 1,
|
||||
CREATE_PIXMAP_USAGE_SCRATCH);
|
||||
if (!pBitmap)
|
||||
return NULL;
|
||||
pGC1 = GetScratchGC (1, pScreen);
|
||||
|
|
26
cfb/cfbblt.c
26
cfb/cfbblt.c
|
@ -207,13 +207,13 @@ MROP_NAME(cfbDoBitblt)(
|
|||
if (nbox > 1)
|
||||
{
|
||||
/* keep ordering in each band, reverse order of bands */
|
||||
pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
|
||||
pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
if(!pboxNew1)
|
||||
return;
|
||||
pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
|
||||
pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pptNew1)
|
||||
{
|
||||
DEALLOCATE_LOCAL(pboxNew1);
|
||||
xfree(pboxNew1);
|
||||
return;
|
||||
}
|
||||
pboxBase = pboxNext = pbox+nbox-1;
|
||||
|
@ -251,16 +251,16 @@ MROP_NAME(cfbDoBitblt)(
|
|||
if (nbox > 1)
|
||||
{
|
||||
/* reverse order of rects in each band */
|
||||
pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
|
||||
pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
|
||||
pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pboxNew2 || !pptNew2)
|
||||
{
|
||||
if (pptNew2) DEALLOCATE_LOCAL(pptNew2);
|
||||
if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2);
|
||||
if (pptNew2) xfree(pptNew2);
|
||||
if (pboxNew2) xfree(pboxNew2);
|
||||
if (pboxNew1)
|
||||
{
|
||||
DEALLOCATE_LOCAL(pptNew1);
|
||||
DEALLOCATE_LOCAL(pboxNew1);
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
@ -922,12 +922,12 @@ bits1 = *--psrc; --pdst; \
|
|||
}
|
||||
if (pboxNew2)
|
||||
{
|
||||
DEALLOCATE_LOCAL(pptNew2);
|
||||
DEALLOCATE_LOCAL(pboxNew2);
|
||||
xfree(pptNew2);
|
||||
xfree(pboxNew2);
|
||||
}
|
||||
if (pboxNew1)
|
||||
{
|
||||
DEALLOCATE_LOCAL(pptNew1);
|
||||
DEALLOCATE_LOCAL(pboxNew1);
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
}
|
||||
|
|
143
cfb/cfbbstore.c
143
cfb/cfbbstore.c
|
@ -1,143 +0,0 @@
|
|||
/*-
|
||||
* cfbbstore.c --
|
||||
* Functions required by the backing-store implementation in MI.
|
||||
*
|
||||
* Copyright (c) 1987 by the Regents of the University of California
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this
|
||||
* software and its documentation for any purpose and without
|
||||
* fee is hereby granted, provided that the above copyright
|
||||
* notice appear in all copies. The University of California
|
||||
* makes no representations about the suitability of this
|
||||
* software for any purpose. It is provided "as is" without
|
||||
* express or implied warranty.
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include "cfb.h"
|
||||
#include <X11/X.h>
|
||||
#include "mibstore.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "windowstr.h"
|
||||
|
||||
/*-
|
||||
*-----------------------------------------------------------------------
|
||||
* cfbSaveAreas --
|
||||
* Function called by miSaveAreas to actually fetch the areas to be
|
||||
* saved into the backing pixmap. This is very simple to do, since
|
||||
* cfbDoBitblt is designed for this very thing. The region to save is
|
||||
* already destination-relative and we're given the offset to the
|
||||
* window origin, so we have only to create an array of points of the
|
||||
* u.l. corners of the boxes in the region translated to the screen
|
||||
* coordinate system and fetch the screen pixmap out of its devPrivate
|
||||
* field....
|
||||
*
|
||||
* Results:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* Data are copied from the screen into the pixmap.
|
||||
*
|
||||
*-----------------------------------------------------------------------
|
||||
*/
|
||||
void
|
||||
cfbSaveAreas(pPixmap, prgnSave, xorg, yorg, pWin)
|
||||
PixmapPtr pPixmap; /* Backing pixmap */
|
||||
RegionPtr prgnSave; /* Region to save (pixmap-relative) */
|
||||
int xorg; /* X origin of region */
|
||||
int yorg; /* Y origin of region */
|
||||
WindowPtr pWin;
|
||||
{
|
||||
register DDXPointPtr pPt;
|
||||
DDXPointPtr pPtsInit;
|
||||
register BoxPtr pBox;
|
||||
register int i;
|
||||
ScreenPtr pScreen = pPixmap->drawable.pScreen;
|
||||
PixmapPtr pScrPix;
|
||||
|
||||
i = REGION_NUM_RECTS(prgnSave);
|
||||
pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i * sizeof(DDXPointRec));
|
||||
if (!pPtsInit)
|
||||
return;
|
||||
|
||||
pBox = REGION_RECTS(prgnSave);
|
||||
pPt = pPtsInit;
|
||||
while (--i >= 0) {
|
||||
pPt->x = pBox->x1 + xorg;
|
||||
pPt->y = pBox->y1 + yorg;
|
||||
pPt++;
|
||||
pBox++;
|
||||
}
|
||||
|
||||
pScrPix = (*pScreen->GetWindowPixmap)(pWin);
|
||||
|
||||
|
||||
cfbDoBitbltCopy((DrawablePtr) pScrPix, (DrawablePtr)pPixmap,
|
||||
GXcopy, prgnSave, pPtsInit, ~0L);
|
||||
|
||||
DEALLOCATE_LOCAL (pPtsInit);
|
||||
}
|
||||
|
||||
/*-
|
||||
*-----------------------------------------------------------------------
|
||||
* cfbRestoreAreas --
|
||||
* Function called by miRestoreAreas to actually fetch the areas to be
|
||||
* restored from the backing pixmap. This is very simple to do, since
|
||||
* cfbDoBitblt is designed for this very thing. The region to restore is
|
||||
* already destination-relative and we're given the offset to the
|
||||
* window origin, so we have only to create an array of points of the
|
||||
* u.l. corners of the boxes in the region translated to the pixmap
|
||||
* coordinate system and fetch the screen pixmap out of its devPrivate
|
||||
* field....
|
||||
*
|
||||
* Results:
|
||||
* None.
|
||||
*
|
||||
* Side Effects:
|
||||
* Data are copied from the pixmap into the screen.
|
||||
*
|
||||
*-----------------------------------------------------------------------
|
||||
*/
|
||||
void
|
||||
cfbRestoreAreas(pPixmap, prgnRestore, xorg, yorg, pWin)
|
||||
PixmapPtr pPixmap; /* Backing pixmap */
|
||||
RegionPtr prgnRestore; /* Region to restore (screen-relative)*/
|
||||
int xorg; /* X origin of window */
|
||||
int yorg; /* Y origin of window */
|
||||
WindowPtr pWin;
|
||||
{
|
||||
register DDXPointPtr pPt;
|
||||
DDXPointPtr pPtsInit;
|
||||
register BoxPtr pBox;
|
||||
register int i;
|
||||
ScreenPtr pScreen = pPixmap->drawable.pScreen;
|
||||
PixmapPtr pScrPix;
|
||||
|
||||
i = REGION_NUM_RECTS(prgnRestore);
|
||||
pPtsInit = (DDXPointPtr)ALLOCATE_LOCAL(i*sizeof(DDXPointRec));
|
||||
if (!pPtsInit)
|
||||
return;
|
||||
|
||||
pBox = REGION_RECTS(prgnRestore);
|
||||
pPt = pPtsInit;
|
||||
while (--i >= 0) {
|
||||
pPt->x = pBox->x1 - xorg;
|
||||
pPt->y = pBox->y1 - yorg;
|
||||
pPt++;
|
||||
pBox++;
|
||||
}
|
||||
|
||||
pScrPix = (*pScreen->GetWindowPixmap)(pWin);
|
||||
|
||||
cfbDoBitbltCopy((DrawablePtr)pPixmap, (DrawablePtr) pScrPix,
|
||||
GXcopy, prgnRestore, pPtsInit, ~0L);
|
||||
|
||||
DEALLOCATE_LOCAL (pPtsInit);
|
||||
}
|
|
@ -196,7 +196,7 @@ cfbPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
|
|||
numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
|
||||
if (numRects > NUM_STACK_RECTS)
|
||||
{
|
||||
pboxClippedBase = (BoxPtr)ALLOCATE_LOCAL(numRects * sizeof(BoxRec));
|
||||
pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
|
||||
if (!pboxClippedBase)
|
||||
return;
|
||||
}
|
||||
|
@ -301,5 +301,5 @@ cfbPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
|
|||
(*BoxFill) (pDrawable, pGC,
|
||||
pboxClipped-pboxClippedBase, pboxClippedBase);
|
||||
if (pboxClippedBase != stackRects)
|
||||
DEALLOCATE_LOCAL(pboxClippedBase);
|
||||
xfree(pboxClippedBase);
|
||||
}
|
||||
|
|
|
@ -186,12 +186,12 @@ int fSorted;
|
|||
n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
|
||||
if ( n == 0 )
|
||||
return;
|
||||
pwidth = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
ppt = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidth = (int *)xalloc(n * sizeof(int));
|
||||
ppt = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!ppt || !pwidth)
|
||||
{
|
||||
if (ppt) DEALLOCATE_LOCAL(ppt);
|
||||
if (pwidth) DEALLOCATE_LOCAL(pwidth);
|
||||
if (ppt) xfree(ppt);
|
||||
if (pwidth) xfree(pwidth);
|
||||
return;
|
||||
}
|
||||
n = miClipSpans( cfbGetCompositeClip(pGC),
|
||||
|
@ -203,8 +203,8 @@ int fSorted;
|
|||
|
||||
(*fill) (pDrawable, n, ppt, pwidth, pGC->tile.pixmap, xrot, yrot, pGC->alu, pGC->planemask);
|
||||
|
||||
DEALLOCATE_LOCAL(ppt);
|
||||
DEALLOCATE_LOCAL(pwidth);
|
||||
xfree(ppt);
|
||||
xfree(pwidth);
|
||||
}
|
||||
|
||||
#if PSZ == 8
|
||||
|
@ -251,12 +251,12 @@ int fSorted;
|
|||
n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
|
||||
if ( n == 0 )
|
||||
return;
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree)
|
||||
{
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -392,8 +392,8 @@ int fSorted;
|
|||
}
|
||||
}
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
#else /* PSZ != 8 */
|
||||
|
@ -434,12 +434,12 @@ int fSorted;
|
|||
n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
|
||||
if ( n == 0 )
|
||||
return;
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree)
|
||||
{
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -599,8 +599,8 @@ int fSorted;
|
|||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
||||
|
@ -648,12 +648,12 @@ cfb8Stipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
if ( n == 0 )
|
||||
return;
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree)
|
||||
{
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -816,8 +816,8 @@ cfb8Stipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
}
|
||||
}
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -862,12 +862,12 @@ cfb8OpaqueStipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
n = nInit * miFindMaxBand(pGC->pCompositeClip);
|
||||
if ( n == 0 )
|
||||
return;
|
||||
pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree)
|
||||
{
|
||||
if (pptFree) DEALLOCATE_LOCAL(pptFree);
|
||||
if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
|
@ -997,8 +997,8 @@ cfb8OpaqueStipple32FS (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
|||
}
|
||||
}
|
||||
}
|
||||
DEALLOCATE_LOCAL(pptFree);
|
||||
DEALLOCATE_LOCAL(pwidthFree);
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
||||
|
|
|
@ -355,7 +355,7 @@ cfbPolyGlyphBlt8Clipped(
|
|||
}
|
||||
if (!numRects)
|
||||
return;
|
||||
clips = (CARD32 *)ALLOCATE_LOCAL ((maxAscent + maxDescent) *
|
||||
clips = (CARD32 *)xalloc ((maxAscent + maxDescent) *
|
||||
sizeof (CARD32));
|
||||
while (nglyph--)
|
||||
{
|
||||
|
@ -471,7 +471,7 @@ cfbPolyGlyphBlt8Clipped(
|
|||
}
|
||||
}
|
||||
}
|
||||
DEALLOCATE_LOCAL (clips);
|
||||
xfree (clips);
|
||||
}
|
||||
|
||||
#endif /* FOUR_BIT_CODE */
|
||||
|
|
|
@ -71,8 +71,6 @@ in this Software without prior written authorization from The Open Group.
|
|||
#undef cfbDoBitbltGeneral
|
||||
#undef cfbDoBitbltOr
|
||||
#undef cfbDoBitbltXor
|
||||
#undef cfbFillBoxSolid
|
||||
#undef cfbFillBoxTile32
|
||||
#undef cfbFillBoxTile32sCopy
|
||||
#undef cfbFillBoxTile32sGeneral
|
||||
#undef cfbFillBoxTileOdd
|
||||
|
@ -108,7 +106,6 @@ in this Software without prior written authorization from The Open Group.
|
|||
#undef cfbNonTEOps
|
||||
#undef cfbNonTEOps1Rect
|
||||
#undef cfbPadPixmap
|
||||
#undef cfbPaintWindow
|
||||
#undef cfbPolyFillArcSolidCopy
|
||||
#undef cfbPolyFillArcSolidGeneral
|
||||
#undef cfbPolyFillRect
|
||||
|
@ -250,8 +247,6 @@ cfb can not hack PSZ yet
|
|||
#define cfbDoBitbltOr CFBNAME(DoBitbltOr)
|
||||
#define cfbDoBitbltXor CFBNAME(DoBitbltXor)
|
||||
#define cfbExpandDirectColors CFBNAME(cfbExpandDirectColors)
|
||||
#define cfbFillBoxSolid CFBNAME(FillBoxSolid)
|
||||
#define cfbFillBoxTile32 CFBNAME(FillBoxTile32)
|
||||
#define cfbFillBoxTile32sCopy CFBNAME(FillBoxTile32sCopy)
|
||||
#define cfbFillBoxTile32sGeneral CFBNAME(FillBoxTile32sGeneral)
|
||||
#define cfbFillBoxTileOdd CFBNAME(FillBoxTileOdd)
|
||||
|
@ -288,7 +283,6 @@ cfb can not hack PSZ yet
|
|||
#define cfbNonTEOps CFBNAME(NonTEOps)
|
||||
#define cfbNonTEOps1Rect CFBNAME(NonTEOps1Rect)
|
||||
#define cfbPadPixmap CFBNAME(PadPixmap)
|
||||
#define cfbPaintWindow CFBNAME(PaintWindow)
|
||||
#define cfbPolyFillArcSolidCopy CFBNAME(PolyFillArcSolidCopy)
|
||||
#define cfbPolyFillArcSolidGeneral CFBNAME(PolyFillArcSolidGeneral)
|
||||
#define cfbPolyFillRect CFBNAME(PolyFillRect)
|
||||
|
|
|
@ -65,11 +65,12 @@ SOFTWARE.
|
|||
#include "cfbmskbits.h"
|
||||
|
||||
PixmapPtr
|
||||
cfbCreatePixmap (pScreen, width, height, depth)
|
||||
cfbCreatePixmap (pScreen, width, height, depth, usage_hint)
|
||||
ScreenPtr pScreen;
|
||||
int width;
|
||||
int height;
|
||||
int depth;
|
||||
unsigned usage_hint;
|
||||
{
|
||||
PixmapPtr pPixmap;
|
||||
size_t datasize;
|
||||
|
@ -122,7 +123,7 @@ cfbCopyPixmap(pSrc)
|
|||
size = pSrc->drawable.height * pSrc->devKind;
|
||||
pScreen = pSrc->drawable.pScreen;
|
||||
pDst = (*pScreen->CreatePixmap) (pScreen, pSrc->drawable.width,
|
||||
pSrc->drawable.height, pSrc->drawable.depth);
|
||||
pSrc->drawable.height, pSrc->drawable.depth, 0);
|
||||
if (!pDst)
|
||||
return NullPixmap;
|
||||
memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
|
||||
|
@ -269,7 +270,7 @@ cfbXRotatePixmap(pPix, rw)
|
|||
int size, tsize;
|
||||
|
||||
tsize = PixmapBytePad(pPix->drawable.width - rot, pPix->drawable.depth);
|
||||
pwTmp = (CfbBits *) ALLOCATE_LOCAL(pPix->drawable.height * tsize);
|
||||
pwTmp = (CfbBits *) xalloc(pPix->drawable.height * tsize);
|
||||
if (!pwTmp)
|
||||
return;
|
||||
/* divide pw (the pixmap) in two vertically at (w - rot) and swap */
|
||||
|
@ -287,7 +288,7 @@ cfbXRotatePixmap(pPix, rw)
|
|||
0, 0, rot, 0,
|
||||
(int)pPix->drawable.width - rot, (int)pPix->drawable.height,
|
||||
tsize, size);
|
||||
DEALLOCATE_LOCAL(pwTmp);
|
||||
xfree(pwTmp);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
@ -327,13 +328,13 @@ cfbYRotatePixmap(pPix, rh)
|
|||
|
||||
nbyDown = rot * pPix->devKind;
|
||||
nbyUp = (pPix->devKind * pPix->drawable.height) - nbyDown;
|
||||
if(!(ptmp = (char *)ALLOCATE_LOCAL(nbyUp)))
|
||||
if(!(ptmp = (char *)xalloc(nbyUp)))
|
||||
return;
|
||||
|
||||
memmove(ptmp, pbase, nbyUp); /* save the low rows */
|
||||
memmove(pbase, pbase+nbyUp, nbyDown); /* slide the top rows down */
|
||||
memmove(pbase+nbyDown, ptmp, nbyUp); /* move lower rows up to row rot */
|
||||
DEALLOCATE_LOCAL(ptmp);
|
||||
xfree(ptmp);
|
||||
}
|
||||
|
||||
void
|
||||
|
|
768
cfb/cfbpntwin.c
768
cfb/cfbpntwin.c
|
@ -1,768 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "windowstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mi.h"
|
||||
|
||||
#ifdef PANORAMIX
|
||||
#include "panoramiX.h"
|
||||
#include "panoramiXsrv.h"
|
||||
#endif
|
||||
|
||||
void
|
||||
cfbPaintWindow(pWin, pRegion, what)
|
||||
WindowPtr pWin;
|
||||
RegionPtr pRegion;
|
||||
int what;
|
||||
{
|
||||
register cfbPrivWin *pPrivWin;
|
||||
WindowPtr pBgWin;
|
||||
|
||||
pPrivWin = cfbGetWindowPrivate(pWin);
|
||||
|
||||
|
||||
switch (what) {
|
||||
case PW_BACKGROUND:
|
||||
switch (pWin->backgroundState) {
|
||||
case None:
|
||||
break;
|
||||
case ParentRelative:
|
||||
do {
|
||||
pWin = pWin->parent;
|
||||
} while (pWin->backgroundState == ParentRelative);
|
||||
(*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion,
|
||||
what);
|
||||
break;
|
||||
case BackgroundPixmap:
|
||||
if (pPrivWin->fastBackground)
|
||||
{
|
||||
cfbFillBoxTile32 ((DrawablePtr)pWin,
|
||||
(int)REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion),
|
||||
pPrivWin->pRotatedBackground);
|
||||
}
|
||||
else
|
||||
{
|
||||
int xorg = pWin->drawable.x;
|
||||
int yorg = pWin->drawable.y;
|
||||
#ifdef PANORAMIX
|
||||
if(!noPanoramiXExtension) {
|
||||
int index = pWin->drawable.pScreen->myNum;
|
||||
if(WindowTable[index] == pWin) {
|
||||
xorg -= panoramiXdataPtr[index].x;
|
||||
yorg -= panoramiXdataPtr[index].y;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
cfbFillBoxTileOdd ((DrawablePtr)pWin,
|
||||
(int)REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion),
|
||||
pWin->background.pixmap,
|
||||
xorg, yorg);
|
||||
}
|
||||
break;
|
||||
case BackgroundPixel:
|
||||
cfbFillBoxSolid ((DrawablePtr)pWin,
|
||||
(int)REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion),
|
||||
pWin->background.pixel);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case PW_BORDER:
|
||||
if (pWin->borderIsPixel)
|
||||
{
|
||||
cfbFillBoxSolid ((DrawablePtr)pWin,
|
||||
(int)REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion),
|
||||
pWin->border.pixel);
|
||||
}
|
||||
else if (pPrivWin->fastBorder)
|
||||
{
|
||||
cfbFillBoxTile32 ((DrawablePtr)pWin,
|
||||
(int)REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion),
|
||||
pPrivWin->pRotatedBorder);
|
||||
}
|
||||
else
|
||||
{
|
||||
int xorg, yorg;
|
||||
|
||||
for (pBgWin = pWin;
|
||||
pBgWin->backgroundState == ParentRelative;
|
||||
pBgWin = pBgWin->parent);
|
||||
|
||||
xorg = pBgWin->drawable.x;
|
||||
yorg = pBgWin->drawable.y;
|
||||
|
||||
#ifdef PANORAMIX
|
||||
if(!noPanoramiXExtension) {
|
||||
int index = pWin->drawable.pScreen->myNum;
|
||||
if(WindowTable[index] == pBgWin) {
|
||||
xorg -= panoramiXdataPtr[index].x;
|
||||
yorg -= panoramiXdataPtr[index].y;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
cfbFillBoxTileOdd ((DrawablePtr)pWin,
|
||||
(int)REGION_NUM_RECTS(pRegion),
|
||||
REGION_RECTS(pRegion),
|
||||
pWin->border.pixmap,
|
||||
xorg, yorg);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Use the RROP macros in copy mode
|
||||
*/
|
||||
|
||||
#define RROP GXcopy
|
||||
#include "cfbrrop.h"
|
||||
|
||||
#ifdef RROP_UNROLL
|
||||
# define Expand(left,right,leftAdjust) {\
|
||||
int part = nmiddle & RROP_UNROLL_MASK; \
|
||||
int widthStep; \
|
||||
widthStep = widthDst - nmiddle - leftAdjust; \
|
||||
nmiddle >>= RROP_UNROLL_SHIFT; \
|
||||
while (h--) { \
|
||||
left \
|
||||
pdst += part; \
|
||||
switch (part) { \
|
||||
RROP_UNROLL_CASE(pdst) \
|
||||
} \
|
||||
m = nmiddle; \
|
||||
while (m) { \
|
||||
pdst += RROP_UNROLL; \
|
||||
RROP_UNROLL_LOOP(pdst) \
|
||||
m--; \
|
||||
} \
|
||||
right \
|
||||
pdst += widthStep; \
|
||||
} \
|
||||
}
|
||||
|
||||
#else
|
||||
# define Expand(left, right, leftAdjust) { \
|
||||
int widthStep; \
|
||||
widthStep = widthDst - nmiddle - leftAdjust; \
|
||||
while (h--) { \
|
||||
left \
|
||||
m = nmiddle; \
|
||||
while (m--) {\
|
||||
RROP_SOLID(pdst); \
|
||||
pdst++; \
|
||||
} \
|
||||
right \
|
||||
pdst += widthStep; \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
cfbFillBoxSolid (pDrawable, nBox, pBox, pixel)
|
||||
DrawablePtr pDrawable;
|
||||
int nBox;
|
||||
BoxPtr pBox;
|
||||
unsigned long pixel;
|
||||
{
|
||||
CfbBits *pdstBase;
|
||||
int widthDst;
|
||||
register int h;
|
||||
register CfbBits *pdst;
|
||||
int nmiddle;
|
||||
int w;
|
||||
#if PSZ == 24
|
||||
int leftIndex, rightIndex;
|
||||
CfbBits piQxelArray[3], *pdstULC; /*upper left corner*/
|
||||
|
||||
piQxelArray[0] = (pixel&0xFFFFFF) | ((pixel&0xFF)<<24);
|
||||
piQxelArray[1] = ((pixel&0xFFFF00)>>8) | ((pixel&0xFFFF)<<16);
|
||||
piQxelArray[2] = ((pixel&0xFFFFFF)<<8) | ((pixel&0xFF0000)>>16);
|
||||
#else
|
||||
register CfbBits rrop_xor;
|
||||
register CfbBits leftMask, rightMask;
|
||||
register int m;
|
||||
#endif
|
||||
|
||||
cfbGetLongWidthAndPointer(pDrawable, widthDst, pdstBase);
|
||||
|
||||
#if PSZ != 24
|
||||
rrop_xor = PFILL(pixel);
|
||||
#endif
|
||||
for (; nBox; nBox--, pBox++)
|
||||
{
|
||||
pdst = pdstBase + pBox->y1 * widthDst;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
w = pBox->x2 - pBox->x1;
|
||||
#if PSZ == 8
|
||||
if (w == 1)
|
||||
{
|
||||
register char *pdstb = ((char *) pdst) + pBox->x1;
|
||||
int incr = widthDst * PGSZB;
|
||||
|
||||
while (h--)
|
||||
{
|
||||
*pdstb = rrop_xor;
|
||||
pdstb += incr;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
/* _Box has x1, y1, x2, y2*/
|
||||
leftIndex = pBox->x1 & 3;
|
||||
rightIndex = ((leftIndex+w)<5)?0:(pBox->x2 &3);
|
||||
nmiddle = w - rightIndex;
|
||||
if(leftIndex){
|
||||
nmiddle -= (4 - leftIndex);
|
||||
}
|
||||
nmiddle >>= 2;
|
||||
if(nmiddle < 0)
|
||||
nmiddle = 0;
|
||||
|
||||
pdst = pdstBase + pBox->y1 * widthDst + ((pBox->x1*3) >> 2);
|
||||
|
||||
switch(leftIndex+w){
|
||||
case 4:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
while(h--){
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = piQxelArray[2];
|
||||
pdst -=2;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
while(h--){
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = piQxelArray[2];
|
||||
pdst -=2;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while(h--){
|
||||
*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
|
||||
pdst++;
|
||||
*pdst-- = piQxelArray[2];
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
while(h--){
|
||||
*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
while(h--){
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
pdst--;
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
while(h--){
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
pdst--;
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while(h--){
|
||||
*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
|
||||
pdst++;
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while(h--){
|
||||
if(leftIndex){
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
}
|
||||
else{
|
||||
*pdst++ = piQxelArray[0];
|
||||
}
|
||||
*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 1: /*only if leftIndex = 0 and w = 1*/
|
||||
while(h--){
|
||||
*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 0: /*never*/
|
||||
break;
|
||||
default:
|
||||
{
|
||||
w = nmiddle;
|
||||
pdstULC = pdst;
|
||||
/* maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);*/
|
||||
while(h--){
|
||||
nmiddle = w;
|
||||
pdst = pdstULC;
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst++ = piQxelArray[2];
|
||||
break;
|
||||
case 2:
|
||||
*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[2];
|
||||
break;
|
||||
case 3:
|
||||
*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
|
||||
pdst++;
|
||||
break;
|
||||
}
|
||||
while(nmiddle--){
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst++ = piQxelArray[2];
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
break;
|
||||
}
|
||||
pdstULC += widthDst;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
#else
|
||||
pdst += (pBox->x1 >> PWSH);
|
||||
if ((pBox->x1 & PIM) + w <= PPW)
|
||||
{
|
||||
maskpartialbits(pBox->x1, w, leftMask);
|
||||
while (h--) {
|
||||
*pdst = (*pdst & ~leftMask) | (rrop_xor & leftMask);
|
||||
pdst += widthDst;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
|
||||
if (leftMask)
|
||||
{
|
||||
if (rightMask)
|
||||
{
|
||||
Expand (RROP_SOLID_MASK (pdst, leftMask); pdst++; ,
|
||||
RROP_SOLID_MASK (pdst, rightMask); ,
|
||||
1)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand (RROP_SOLID_MASK (pdst, leftMask); pdst++;,
|
||||
;,
|
||||
1)
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (rightMask)
|
||||
{
|
||||
Expand (;,
|
||||
RROP_SOLID_MASK (pdst, rightMask);,
|
||||
0)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand (;,
|
||||
;,
|
||||
0)
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#if PSZ == 8
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
cfbFillBoxTile32 (pDrawable, nBox, pBox, tile)
|
||||
DrawablePtr pDrawable;
|
||||
int nBox; /* number of boxes to fill */
|
||||
BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
PixmapPtr tile; /* rotated, expanded tile */
|
||||
{
|
||||
register CfbBits *pdst;
|
||||
CfbBits *psrc;
|
||||
int tileHeight;
|
||||
|
||||
int widthDst;
|
||||
int w;
|
||||
int h;
|
||||
int nmiddle;
|
||||
int y;
|
||||
int srcy;
|
||||
|
||||
CfbBits *pdstBase;
|
||||
#if PSZ == 24
|
||||
int leftIndex, rightIndex;
|
||||
CfbBits piQxelArray[3], *pdstULC;
|
||||
#else
|
||||
register CfbBits rrop_xor;
|
||||
register CfbBits leftMask;
|
||||
register CfbBits rightMask;
|
||||
register int m;
|
||||
#endif
|
||||
|
||||
tileHeight = tile->drawable.height;
|
||||
psrc = (CfbBits *)tile->devPrivate.ptr;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase);
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
w = pBox->x2 - pBox->x1;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
y = pBox->y1;
|
||||
leftIndex = pBox->x1 & 3;
|
||||
/* rightIndex = ((leftIndex+w)<5)?0:pBox->x2 &3;*/
|
||||
rightIndex = pBox->x2 &3;
|
||||
nmiddle = w - rightIndex;
|
||||
if(leftIndex){
|
||||
nmiddle -= (4 - leftIndex);
|
||||
}
|
||||
nmiddle >>= 2;
|
||||
if(nmiddle < 0)
|
||||
nmiddle = 0;
|
||||
|
||||
pdst = pdstBase + ((pBox->x1 *3)>> 2) + pBox->y1 * widthDst;
|
||||
srcy = y % tileHeight;
|
||||
|
||||
#define StepTile piQxelArray[0] = (psrc[srcy] & 0xFFFFFF) | ((psrc[srcy] & 0xFF)<<24); \
|
||||
piQxelArray[1] = (psrc[srcy] & 0xFFFF00) | ((psrc[srcy] & 0xFFFF)<<16); \
|
||||
piQxelArray[2] = ((psrc[srcy] & 0xFF0000)>>16) | \
|
||||
((psrc[srcy] & 0xFFFFFF)<<8); \
|
||||
/*rrop_xor = psrc[srcy];*/ \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0;
|
||||
|
||||
switch(leftIndex+w){
|
||||
case 4:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = piQxelArray[2];
|
||||
pdst-=2;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = piQxelArray[2];
|
||||
pdst-=2;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
|
||||
pdst++;
|
||||
*pdst-- = piQxelArray[2];
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
pdst--;
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
pdst--;
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
|
||||
pdst++;
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while(h--){
|
||||
StepTile
|
||||
if(leftIndex){
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
}
|
||||
else{
|
||||
*pdst++ = piQxelArray[0];
|
||||
}
|
||||
*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
|
||||
pdst--;
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 1: /*only if leftIndex = 0 and w = 1*/
|
||||
while(h--){
|
||||
StepTile
|
||||
*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
|
||||
pdst += widthDst;
|
||||
}
|
||||
break;
|
||||
case 0: /*never*/
|
||||
break;
|
||||
default:
|
||||
{
|
||||
w = nmiddle;
|
||||
pdstULC = pdst;
|
||||
|
||||
while(h--){
|
||||
StepTile
|
||||
nmiddle = w;
|
||||
pdst = pdstULC;
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*pdst = ((*pdst) & 0xFFFFFF) | (piQxelArray[0] & 0xFF000000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst++ = piQxelArray[2];
|
||||
break;
|
||||
case 2:
|
||||
*pdst = ((*pdst) & 0xFFFF) | (piQxelArray[1] & 0xFFFF0000);
|
||||
pdst++;
|
||||
*pdst++ = piQxelArray[2];
|
||||
break;
|
||||
case 3:
|
||||
*pdst = ((*pdst) & 0xFF) | (piQxelArray[2] & 0xFFFFFF00);
|
||||
pdst++;
|
||||
break;
|
||||
}
|
||||
while(nmiddle--){
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst++ = piQxelArray[2];
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*pdst = ((*pdst) & 0xFF000000) | (piQxelArray[0] & 0xFFFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst = ((*pdst) & 0xFFFF0000) | (piQxelArray[1] & 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*pdst++ = piQxelArray[0];
|
||||
*pdst++ = piQxelArray[1];
|
||||
*pdst = ((*pdst) & 0xFFFFFF00) | (piQxelArray[2] & 0xFF);
|
||||
break;
|
||||
}
|
||||
pdstULC += widthDst;
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
w = pBox->x2 - pBox->x1;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
y = pBox->y1;
|
||||
pdst = pdstBase + (pBox->y1 * widthDst) + (pBox->x1 >> PWSH);
|
||||
srcy = y % tileHeight;
|
||||
|
||||
#define StepTile rrop_xor = psrc[srcy]; \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0;
|
||||
|
||||
if ( ((pBox->x1 & PIM) + w) < PPW)
|
||||
{
|
||||
maskpartialbits(pBox->x1, w, leftMask);
|
||||
rightMask = ~leftMask;
|
||||
while (h--)
|
||||
{
|
||||
StepTile
|
||||
*pdst = (*pdst & rightMask) | (rrop_xor & leftMask);
|
||||
pdst += widthDst;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(pBox->x1, w, leftMask, rightMask, nmiddle);
|
||||
|
||||
if (leftMask)
|
||||
{
|
||||
if (rightMask)
|
||||
{
|
||||
Expand (StepTile
|
||||
RROP_SOLID_MASK(pdst, leftMask); pdst++;,
|
||||
RROP_SOLID_MASK(pdst, rightMask);,
|
||||
1)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand (StepTile
|
||||
RROP_SOLID_MASK(pdst, leftMask); pdst++;,
|
||||
;,
|
||||
1)
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (rightMask)
|
||||
{
|
||||
Expand (StepTile
|
||||
,
|
||||
RROP_SOLID_MASK(pdst, rightMask);,
|
||||
0)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand (StepTile
|
||||
,
|
||||
;,
|
||||
0)
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
pBox++;
|
||||
}
|
||||
}
|
|
@ -46,14 +46,6 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
#include "cfbmskbits.h"
|
||||
#include "mibstore.h"
|
||||
|
||||
BSFuncRec cfbBSFuncRec = {
|
||||
cfbSaveAreas,
|
||||
cfbRestoreAreas,
|
||||
(BackingStoreSetClipmaskRgnProcPtr) 0,
|
||||
(BackingStoreGetImagePixmapProcPtr) 0,
|
||||
(BackingStoreGetSpansPixmapProcPtr) 0,
|
||||
};
|
||||
|
||||
Bool
|
||||
cfbCloseScreen (index, pScreen)
|
||||
int index;
|
||||
|
@ -96,7 +88,7 @@ cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
|||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
if (!cfbAllocatePrivates(pScreen, (int *) 0, (int *) 0))
|
||||
if (!cfbAllocatePrivates(pScreen, NULL))
|
||||
return FALSE;
|
||||
pScreen->defColormap = FakeClientID(0);
|
||||
/* let CreateDefColormap do whatever it wants for pixels */
|
||||
|
@ -111,8 +103,6 @@ cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
|||
pScreen->ChangeWindowAttributes = cfbChangeWindowAttributes;
|
||||
pScreen->RealizeWindow = cfbMapWindow;
|
||||
pScreen->UnrealizeWindow = cfbUnmapWindow;
|
||||
pScreen->PaintWindowBackground = cfbPaintWindow;
|
||||
pScreen->PaintWindowBorder = cfbPaintWindow;
|
||||
pScreen->CopyWindow = cfbCopyWindow;
|
||||
pScreen->CreatePixmap = cfbCreatePixmap;
|
||||
pScreen->DestroyPixmap = cfbDestroyPixmap;
|
||||
|
@ -184,7 +174,6 @@ cfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
|||
pScreen->devPrivates[cfbScreenPrivateIndex].ptr = pScreen->devPrivate;
|
||||
pScreen->devPrivate = oldDevPrivate;
|
||||
#endif
|
||||
pScreen->BackingStoreFuncs = cfbBSFuncRec;
|
||||
pScreen->GetScreenPixmap = cfbGetScreenPixmap;
|
||||
pScreen->SetScreenPixmap = cfbSetScreenPixmap;
|
||||
return TRUE;
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user