andreacavalli
/
xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove readmask from screen block/wakeup handler 

With no users of the interface needing the readmask anymore, we can
remove it from the argument passed to these functions.

Signed-off-by: Keith Packard <keithp@keithp.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
This commit is contained in:
Keith Packard 2015-09-01 11:20:04 -07:00 committed by Adam Jackson
parent 410bc04748
commit fb0802113b
22 changed files with 77 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
composite/compalloc.c
View File

@ -55,13 +55,13 @@ compScreenUpdate(ScreenPtr pScreen)
}
static void
compBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
compBlockHandler(ScreenPtr pScreen, void *pTimeout)
{
CompScreenPtr cs = GetCompScreen(pScreen);
pScreen->BlockHandler = cs->BlockHandler;
compScreenUpdate(pScreen);
(*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
(*pScreen->BlockHandler) (pScreen, pTimeout);
/* Next damage will restore the block handler */
cs->BlockHandler = NULL;

18
dix/dixutils.c
View File

@ -385,16 +385,13 @@ BlockHandler(void *pTimeout, void *pReadmask)
++inHandler;
for (i = 0; i < numHandlers; i++)
if (!handlers[i].deleted)
(*handlers[i].BlockHandler) (handlers[i].blockData,
pTimeout, pReadmask);
(*handlers[i].BlockHandler) (handlers[i].blockData, pTimeout, pReadmask);
for (i = 0; i < screenInfo.numGPUScreens; i++)
(*screenInfo.gpuscreens[i]->BlockHandler) (screenInfo.gpuscreens[i],
pTimeout, pReadmask);
(*screenInfo.gpuscreens[i]->BlockHandler) (screenInfo.gpuscreens[i], pTimeout);
for (i = 0; i < screenInfo.numScreens; i++)
(*screenInfo.screens[i]->BlockHandler) (screenInfo.screens[i],
pTimeout, pReadmask);
(*screenInfo.screens[i]->BlockHandler) (screenInfo.screens[i], pTimeout);
if (handlerDeleted) {
for (i = 0; i < numHandlers;)
@ -422,15 +419,12 @@ WakeupHandler(int result, void *pReadmask)
++inHandler;
for (i = 0; i < screenInfo.numScreens; i++)
(*screenInfo.screens[i]->WakeupHandler) (screenInfo.screens[i],
result, pReadmask);
(*screenInfo.screens[i]->WakeupHandler) (screenInfo.screens[i], result);
for (i = 0; i < screenInfo.numGPUScreens; i++)
(*screenInfo.gpuscreens[i]->WakeupHandler) (screenInfo.gpuscreens[i],
result, pReadmask);
(*screenInfo.gpuscreens[i]->WakeupHandler) (screenInfo.gpuscreens[i], result);
for (i = numHandlers - 1; i >= 0; i--)
if (!handlers[i].deleted)
(*handlers[i].WakeupHandler) (handlers[i].blockData,
result, pReadmask);
(*handlers[i].WakeupHandler) (handlers[i].blockData, result, pReadmask);
if (handlerDeleted) {
for (i = 0; i < numHandlers;)
if (handlers[i].deleted) {

8
doc/Xinput.xml
View File

@ -210,7 +210,7 @@ A sample InitInput implementation is shown below.
<literallayout class="monospaced">
InitInput(argc,argv)
{
int i, numdevs, ReadInput();
int i, numdevs;
DeviceIntPtr dev;
LocalDevice localdevs[LOCAL_MAX_DEVS];
DeviceProc kbdproc, ptrproc, extproc;
@ -223,12 +223,6 @@ InitInput(argc,argv)
open_input_devices (&amp;numdevs, localdevs);
/**************************************************************
* Register a WakeupHandler to handle input when it is generated.
***************************************************************/
RegisterBlockAndWakeupHandlers (NoopDDA, ReadInput, NULL);
/**************************************************************
* Register the input devices with DIX.
***************************************************************/

59
doc/Xserver-spec.xml
View File

@ -674,30 +674,22 @@ If WaitForSomething() decides it is about to do something that might block
routine called BlockHandler().
<blockquote>
<programlisting>
void BlockHandler(pTimeout, pReadmask)
pointer pTimeout;
pointer pReadmask;
void BlockHandler(void *pTimeout)
</programlisting>
</blockquote>
The types of the arguments are for agreement between the OS and DDX
implementations, but the pTimeout is a pointer to the information
determining how long the block is allowed to last, and the
pReadmask is a pointer to the information describing the descriptors
that will be waited on.
determining how long the block is allowed to last.
</para>
<para>
In the sample server, pTimeout is a pointer, and pReadmask is
the address of the select() mask for reading.
In the sample server, pTimeout is a pointer.
</para>
<para>
The DIX BlockHandler() iterates through the Screens, for each one calling
its BlockHandler. A BlockHandler is declared thus:
<blockquote>
<programlisting>
void xxxBlockHandler(pScreen, pTimeout, pReadmask)
ScreenPtr pScreen;
pointer pTimeout;
pointer pReadmask;
void xxxBlockHandler(ScreenPtr pScreen, void *pTimeout)
</programlisting>
</blockquote>
The arguments are a pointer to the Screen, and the arguments to the
@ -709,27 +701,20 @@ block, even if it didn't actually block, it must call the DIX routine
WakeupHandler().
<blockquote>
<programlisting>
void WakeupHandler(result, pReadmask)
int result;
pointer pReadmask;
void WakeupHandler(int result)
</programlisting>
</blockquote>
Once again, the types are not specified by DIX. The result is the
success indicator for the thing that (may have) blocked,
and the pReadmask is a mask of the descriptors that came active.
In the sample server, result is the result from select() (or equivalent
operating system function), and pReadmask is
the address of the select() mask for reading.
success indicator for the thing that (may have) blocked.
In the sample server, result is the result from select() (or equivalent
operating system function).
</para>
<para>
The DIX WakeupHandler() calls each Screen's
WakeupHandler. A WakeupHandler is declared thus:
<blockquote>
<programlisting>
void xxxWakeupHandler(pScreen, result, pReadmask)
ScreenPtr pScreen;
unsigned long result;
pointer pReadmask;
void xxxWakeupHandler(ScreenPtr pScreen, int result)
</programlisting>
</blockquote>
The arguments are the Screen, of the Screen, and the arguments to
@ -741,8 +726,8 @@ block and wakeup handlers (only together) using:
<blockquote>
<programlisting>
Bool RegisterBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData)
BlockHandlerProcPtr blockHandler;
WakeupHandlerProcPtr wakeupHandler;
ServerBlockHandlerProcPtr blockHandler;
ServerWakeupHandlerProcPtr wakeupHandler;
pointer blockData;
</programlisting>
</blockquote>
@ -752,8 +737,8 @@ memory. To remove a registered Block handler at other than server reset time
<blockquote>
<programlisting>
RemoveBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData)
BlockHandlerProcPtr blockHandler;
WakeupHandlerProcPtr wakeupHandler;
ServerBlockHandlerProcPtr blockHandler;
ServerWakeupHandlerProcPtr wakeupHandler;
pointer blockData;
</programlisting>
</blockquote>
@ -761,18 +746,15 @@ All three arguments must match the values passed to
RegisterBlockAndWakeupHandlers.
</para>
<para>
These registered block handlers are called after the per-screen handlers:
These registered block handlers are called before the per-screen handlers:
<blockquote>
<programlisting>
void (*BlockHandler) (blockData, pptv, pReadmask)
pointer blockData;
OsTimerPtr pptv;
pointer pReadmask;
void (*ServerBlockHandler) (void *blockData, void *pTimeout)
</programlisting>
</blockquote>
</para>
<para>
Sometimes block handlers need to adjust the time in a OSTimePtr structure,
Sometimes block handlers need to adjust the time referenced by pTimeout,
which on UNIX family systems is generally represented by a struct timeval
consisting of seconds and microseconds in 32 bit values.
As a convenience to reduce error prone struct timeval computations which
@ -780,20 +762,17 @@ require modulus arithmetic and correct overflow behavior in the face of
millisecond wrapping through 32 bits,
<blockquote><programlisting>
void AdjustWaitForDelay(pointer /*waitTime*, unsigned long /* newdelay */)
void AdjustWaitForDelay(void *pTimeout, unsigned long newdelay)
</programlisting></blockquote>
has been provided.
</para>
<para>
Any wakeup handlers registered with RegisterBlockAndWakeupHandlers will
be called before the Screen handlers:
be called after the Screen handlers:
<blockquote><programlisting>
void (*WakeupHandler) (blockData, err, pReadmask)
pointer blockData;
int err;
pointer pReadmask;
void (*ServerWakeupHandler) (void *blockData, int result)
</programlisting></blockquote>
</para>
<para>

10
exa/exa.c
View File

@ -702,8 +702,7 @@ exaCreateScreenResources(ScreenPtr pScreen)
}
static void
ExaBlockHandler(ScreenPtr pScreen, void *pTimeout,
void *pReadmask)
ExaBlockHandler(ScreenPtr pScreen, void *pTimeout)
{
ExaScreenPriv(pScreen);
@ -712,7 +711,7 @@ ExaBlockHandler(ScreenPtr pScreen, void *pTimeout,
exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);
unwrap(pExaScr, pScreen, BlockHandler);
(*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
(*pScreen->BlockHandler) (pScreen, pTimeout);
wrap(pExaScr, pScreen, BlockHandler, ExaBlockHandler);
/* The rest only applies to classic EXA */
@ -732,13 +731,12 @@ ExaBlockHandler(ScreenPtr pScreen, void *pTimeout,
}
static void
ExaWakeupHandler(ScreenPtr pScreen, unsigned long result,
void *pReadmask)
ExaWakeupHandler(ScreenPtr pScreen, int result)
{
ExaScreenPriv(pScreen);
unwrap(pExaScr, pScreen, WakeupHandler);
(*pScreen->WakeupHandler) (pScreen, result, pReadmask);
(*pScreen->WakeupHandler) (pScreen, result);
wrap(pExaScr, pScreen, WakeupHandler, ExaWakeupHandler);
if (result == 0 && pExaScr->numOffscreenAvailable > 1) {

4
glamor/glamor.c
View File

@ -257,7 +257,7 @@ glamor_block_handler(ScreenPtr screen)
}
static void
_glamor_block_handler(ScreenPtr screen, void *timeout, void *readmask)
_glamor_block_handler(ScreenPtr screen, void *timeout)
{
glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
@ -265,7 +265,7 @@ _glamor_block_handler(ScreenPtr screen, void *timeout, void *readmask)
glFlush();
screen->BlockHandler = glamor_priv->saved_procs.block_handler;
screen->BlockHandler(screen, timeout, readmask);
screen->BlockHandler(screen, timeout);
glamor_priv->saved_procs.block_handler = screen->BlockHandler;
screen->BlockHandler = _glamor_block_handler;
}

4
hw/kdrive/ephyr/ephyr.c
View File

@ -347,14 +347,14 @@ ephyrEventWorkProc(ClientPtr client, void *closure)
}
static void
ephyrScreenBlockHandler(ScreenPtr pScreen, void *timeout, void *pRead)
ephyrScreenBlockHandler(ScreenPtr pScreen, void *timeout)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
EphyrScrPriv *scrpriv = screen->driver;
pScreen->BlockHandler = scrpriv->BlockHandler;
(*pScreen->BlockHandler)(pScreen, timeout, pRead);
(*pScreen->BlockHandler)(pScreen, timeout);
scrpriv->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = ephyrScreenBlockHandler;

6
hw/kdrive/src/kdrive.h
View File

@ -527,12 +527,10 @@ void
KdScreenToPointerCoords(int *x, int *y);
void
KdBlockHandler(ScreenPtr pScreen, void *timeout, void *readmask);
KdBlockHandler(ScreenPtr pScreen, void *timeout);
void
KdWakeupHandler(ScreenPtr pScreen, unsigned long result, void *readmask);
KdWakeupHandler(ScreenPtr pScreen, int result);
void
KdDisableInput(void);

4
hw/kdrive/src/kinput.c
View File

@ -1961,7 +1961,7 @@ _KdEnqueuePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z,
}
void
KdBlockHandler(ScreenPtr pScreen, void *timeo, void *readmask)
KdBlockHandler(ScreenPtr pScreen, void *timeo)
{
KdPointerInfo *pi;
int myTimeout = 0;
@ -1987,7 +1987,7 @@ KdBlockHandler(ScreenPtr pScreen, void *timeo, void *readmask)
}
void
KdWakeupHandler(ScreenPtr pScreen, unsigned long lresult, void *readmask)
KdWakeupHandler(ScreenPtr pScreen, int result)
{
KdPointerInfo *pi;

10
hw/xfree86/common/xf86VGAarbiter.c
View File

@ -265,23 +265,21 @@ VGAarbiterCloseScreen(ScreenPtr pScreen)
}
static void
VGAarbiterBlockHandler(ScreenPtr pScreen,
void *pTimeout, void *pReadmask)
VGAarbiterBlockHandler(ScreenPtr pScreen, void *pTimeout)
{
SCREEN_PROLOG(BlockHandler);
VGAGet(pScreen);
pScreen->BlockHandler(pScreen, pTimeout, pReadmask);
pScreen->BlockHandler(pScreen, pTimeout);
VGAPut();
SCREEN_EPILOG(BlockHandler, VGAarbiterBlockHandler);
}
static void
VGAarbiterWakeupHandler(ScreenPtr pScreen, unsigned long result,
void *pReadmask)
VGAarbiterWakeupHandler(ScreenPtr pScreen, int result)
{
SCREEN_PROLOG(WakeupHandler);
VGAGet(pScreen);
pScreen->WakeupHandler(pScreen, result, pReadmask);
pScreen->WakeupHandler(pScreen, result);
VGAPut();
SCREEN_EPILOG(WakeupHandler, VGAarbiterWakeupHandler);
}

6
hw/xfree86/common/xf86VGAarbiterPriv.h
View File

@ -146,10 +146,8 @@ typedef struct _VGAarbiterGC {
} VGAarbiterGCRec, *VGAarbiterGCPtr;
/* Screen funcs */
static void VGAarbiterBlockHandler(ScreenPtr pScreen, void *pTimeout,
void *pReadmask);
static void VGAarbiterWakeupHandler(ScreenPtr pScreen,
unsigned long result, void *pReadmask);
static void VGAarbiterBlockHandler(ScreenPtr pScreen, void *pTimeout);
static void VGAarbiterWakeupHandler(ScreenPtr pScreen, int result);
static Bool VGAarbiterCloseScreen(ScreenPtr pScreen);
static void VGAarbiterGetImage(DrawablePtr pDrawable, int sx, int sy, int w,
int h, unsigned int format,

12
hw/xfree86/dri/dri.c
View File

@ -1676,8 +1676,7 @@ DRIWakeupHandler(void *wakeupData, int result, void *pReadmask)
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
if (pDRIPriv && pDRIPriv->pDriverInfo->wrap.WakeupHandler)
(*pDRIPriv->pDriverInfo->wrap.WakeupHandler) (pScreen,
result, pReadmask);
(*pDRIPriv->pDriverInfo->wrap.WakeupHandler) (pScreen, result);
}
}
@ -1691,14 +1690,12 @@ DRIBlockHandler(void *blockData, OSTimePtr pTimeout, void *pReadmask)
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
if (pDRIPriv && pDRIPriv->pDriverInfo->wrap.BlockHandler)
(*pDRIPriv->pDriverInfo->wrap.BlockHandler) (pScreen,
pTimeout, pReadmask);
(*pDRIPriv->pDriverInfo->wrap.BlockHandler) (pScreen, pTimeout);
}
}
void
DRIDoWakeupHandler(ScreenPtr pScreen,
unsigned long result, void *pReadmask)
DRIDoWakeupHandler(ScreenPtr pScreen, int result)
{
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
@ -1715,8 +1712,7 @@ DRIDoWakeupHandler(ScreenPtr pScreen,
}
void
DRIDoBlockHandler(ScreenPtr pScreen,
void *pTimeout, void *pReadmask)
DRIDoBlockHandler(ScreenPtr pScreen, void *timeout)
{
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);

7
hw/xfree86/dri/dri.h
View File

@ -269,12 +269,9 @@ extern _X_EXPORT void DRIWakeupHandler(void *wakeupData,
extern _X_EXPORT void DRIBlockHandler(void *blockData,
OSTimePtr pTimeout, void *pReadmask);
extern _X_EXPORT void DRIDoWakeupHandler(ScreenPtr pScreen,
unsigned long result,
void *pReadmask);
extern _X_EXPORT void DRIDoWakeupHandler(ScreenPtr pScreen, int result);
extern _X_EXPORT void DRIDoBlockHandler(ScreenPtr pScreen,
void *pTimeout, void *pReadmask);
extern _X_EXPORT void DRIDoBlockHandler(ScreenPtr pScreen, void *timeout);
extern _X_EXPORT void DRISwapContext(int drmFD, void *oldctx, void *newctx);

8
hw/xfree86/drivers/modesetting/driver.c
View File

@ -639,12 +639,12 @@ ms_dirty_get_ent(ScreenPtr screen, PixmapPtr slave_dst)
}
static void
msBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
msBlockHandler(ScreenPtr pScreen, void *timeout)
{
modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
pScreen->BlockHandler = ms->BlockHandler;
pScreen->BlockHandler(pScreen, pTimeout, pReadmask);
pScreen->BlockHandler(pScreen, timeout);
ms->BlockHandler = pScreen->BlockHandler;
pScreen->BlockHandler = msBlockHandler;
if (pScreen->isGPU && !ms->drmmode.reverse_prime_offload_mode)
@ -656,12 +656,12 @@ msBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
}
static void
msBlockHandler_oneshot(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
msBlockHandler_oneshot(ScreenPtr pScreen, void *pTimeout)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
modesettingPtr ms = modesettingPTR(pScrn);
msBlockHandler(pScreen, pTimeout, pReadmask);
msBlockHandler(pScreen, pTimeout);
drmmode_set_desired_modes(pScrn, &ms->drmmode, TRUE);
}

5
hw/xfree86/modes/xf86Rotate.c
View File

@ -221,8 +221,7 @@ xf86RotateRedisplay(ScreenPtr pScreen)
}
static void
xf86RotateBlockHandler(ScreenPtr pScreen,
void *pTimeout, void *pReadmask)
xf86RotateBlockHandler(ScreenPtr pScreen, void *pTimeout)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
@ -235,7 +234,7 @@ xf86RotateBlockHandler(ScreenPtr pScreen,
xf86RotateRedisplay(pScreen);
(*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
(*pScreen->BlockHandler) (pScreen, pTimeout);
/* Re-wrap if we still need this hook */
if (xf86_config->rotation_damage != NULL) {

8
hw/xquartz/quartzCocoa.m
View File

@ -48,9 +48,7 @@
* Clean out any autoreleased objects.
*/
void
QuartzBlockHandler(void *blockData,
OSTimePtr pTimeout,
void *pReadmask)
QuartzBlockHandler(void *blockData, void *pTimeout)
{
static NSAutoreleasePool *aPool = nil;
@ -62,9 +60,7 @@ QuartzBlockHandler(void *blockData,
* QuartzWakeupHandler
*/
void
QuartzWakeupHandler(void *blockData,
int result,
void *pReadmask)
QuartzWakeupHandler(void *blockData, int result)
{
// nothing here
}

5
hw/xquartz/quartzCommon.h
View File

@ -47,8 +47,9 @@ extern int aquaMenuBarHeight;
extern const char *quartzOpenGLBundle;
void
QuartzBlockHandler(void *blockData, OSTimePtr pTimeout, void *pReadmask);
QuartzBlockHandler(void *blockData, void *pTimeout);
void
QuartzWakeupHandler(void *blockData, int result, void *pReadmask);
QuartzWakeupHandler(void *blockData, int result);
#endif /* _QUARTZCOMMON_H */

4
hw/xwin/win.h
View File

@ -902,9 +902,7 @@ Bool
*/
void
winWakeupHandler(ScreenPtr pScreen,
unsigned long ulResult, void *pReadmask);
winWakeupHandler(ScreenPtr pScreen, int iResult);
/*
* winwindow.c

3
hw/xwin/winwakeup.c
View File

@ -38,8 +38,7 @@
/* See Porting Layer Definition - p. 7 */
void
winWakeupHandler(ScreenPtr pScreen,
unsigned long ulResult, void *pReadmask)
winWakeupHandler(ScreenPtr pScreen, int iResult)
{
MSG msg;

11
include/scrnintstr.h
View File

@ -258,12 +258,15 @@ typedef void (*ResolveColorProcPtr) (unsigned short * /*pred */ ,
typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ );
typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen,
void *pTimeout,
void *pReadmask);
void *timeout);
/* result has three possible values:
* < 0 - error
* = 0 - timeout
* > 0 - activity
*/
typedef void (*ScreenWakeupHandlerProcPtr) (ScreenPtr pScreen,
unsigned long result,
void *pReadMask);
int result);
typedef Bool (*CreateScreenResourcesProcPtr) (ScreenPtr /*pScreen */ );

8
mi/misprite.c
View File

@ -198,8 +198,7 @@ static void miSpriteSourceValidate(DrawablePtr pDrawable, int x, int y,
unsigned int subWindowMode);
static void miSpriteCopyWindow(WindowPtr pWindow,
DDXPointRec ptOldOrg, RegionPtr prgnSrc);
static void miSpriteBlockHandler(ScreenPtr pScreen,
void *pTimeout, void *pReadMask);
static void miSpriteBlockHandler(ScreenPtr pScreen, void *timeout);
static void miSpriteInstallColormap(ColormapPtr pMap);
static void miSpriteStoreColors(ColormapPtr pMap, int ndef, xColorItem * pdef);
@ -512,8 +511,7 @@ miSpriteCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
}
static void
miSpriteBlockHandler(ScreenPtr pScreen, void *pTimeout,
void *pReadmask)
miSpriteBlockHandler(ScreenPtr pScreen, void *timeout)
{
miSpriteScreenPtr pPriv = GetSpriteScreen(pScreen);
DeviceIntPtr pDev;
@ -545,7 +543,7 @@ miSpriteBlockHandler(ScreenPtr pScreen, void *pTimeout,
}
}
(*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
(*pScreen->BlockHandler) (pScreen, timeout);
if (WorkToDo)
SCREEN_EPILOGUE(pPriv, pScreen, BlockHandler);

4
miext/shadow/shadow.c
View File

@ -65,14 +65,14 @@ shadowRedisplay(ScreenPtr pScreen)
}
static void
shadowBlockHandler(ScreenPtr pScreen, void *timeout, void *pRead)
shadowBlockHandler(ScreenPtr pScreen, void *timeout)
{
shadowBuf(pScreen);
shadowRedisplay(pScreen);
unwrap(pBuf, pScreen, BlockHandler);
pScreen->BlockHandler(pScreen, timeout, pRead);
pScreen->BlockHandler(pScreen, timeout);
wrap(pBuf, pScreen, BlockHandler);
}