frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dmx: Remove ShadowFB support 

This has been listed as deprecated ever since DMX was merged.

Reviewed-by: Peter Hutterer <peter.hutterer@who-t.net>
Signed-off-by: Adam Jackson <ajax@redhat.com>
This commit is contained in:
Adam Jackson 2012-10-16 14:56:18 -04:00
parent 19d3a7cb5d
commit e674815e0a
9 changed files with 93 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hw/dmx/Makefile.am
View File

@ -56,8 +56,6 @@ Xdmx_SOURCES = dmx.c \
dmxprop.h \ dmxprop.h \
dmxscrinit.c \ dmxscrinit.c \
dmxscrinit.h \ dmxscrinit.h \
dmxshadow.c \
dmxshadow.h \
dmxstat.c \ dmxstat.c \
dmxstat.h \ dmxstat.h \
dmxsync.c \ dmxsync.c \

4
hw/dmx/dmx.h
View File

@ -254,10 +254,6 @@ typedef struct _DMXScreenInfo {
/* Global variables available to all Xserver/hw/dmx routines. */ /* Global variables available to all Xserver/hw/dmx routines. */
extern int dmxNumScreens; /**< Number of dmxScreens */ extern int dmxNumScreens; /**< Number of dmxScreens */
extern DMXScreenInfo *dmxScreens; /**< List of outputs */ extern DMXScreenInfo *dmxScreens; /**< List of outputs */
extern int dmxShadowFB; /**< Non-zero if using
* shadow frame-buffer
* (deprecated) */
extern XErrorEvent dmxLastErrorEvent; /**< Last error that extern XErrorEvent dmxLastErrorEvent; /**< Last error that
* occurred */ * occurred */

10
hw/dmx/dmxinit.c
View File

@ -82,8 +82,6 @@ DMXScreenInfo *dmxScreens;
int dmxNumInputs; int dmxNumInputs;
DMXInputInfo *dmxInputs; DMXInputInfo *dmxInputs;
int dmxShadowFB = FALSE;
XErrorEvent dmxLastErrorEvent; XErrorEvent dmxLastErrorEvent;
Bool dmxErrorOccurred = FALSE; Bool dmxErrorOccurred = FALSE;
@ -854,9 +852,6 @@ InitOutput(ScreenInfo * pScreenInfo, int argc, char *argv[])
/* Initialized things that need timer hooks */ /* Initialized things that need timer hooks */
dmxStatInit(); dmxStatInit();
dmxSyncInit(); /* Calls RegisterBlockAndWakeupHandlers */ dmxSyncInit(); /* Calls RegisterBlockAndWakeupHandlers */
dmxLog(dmxInfo, "Shadow framebuffer support %s\n",
dmxShadowFB ? "enabled" : "disabled");
} }
/* RATS: Assuming the fp string (which comes from the command-line argv /* RATS: Assuming the fp string (which comes from the command-line argv
@ -951,10 +946,6 @@ ddxProcessArgument(int argc, char *argv[], int i)
retval = 2; retval = 2;
} }
else if (!strcmp(argv[i], "-noshadowfb")) { else if (!strcmp(argv[i], "-noshadowfb")) {
dmxLog(dmxWarning,
"-noshadowfb has been deprecated "
"since it is now the default\n");
dmxShadowFB = FALSE;
retval = 1; retval = 1;
} }
else if (!strcmp(argv[i], "-nomulticursor")) { else if (!strcmp(argv[i], "-nomulticursor")) {
@ -962,7 +953,6 @@ ddxProcessArgument(int argc, char *argv[], int i)
retval = 1; retval = 1;
} }
else if (!strcmp(argv[i], "-shadowfb")) { else if (!strcmp(argv[i], "-shadowfb")) {
dmxShadowFB = TRUE;
retval = 1; retval = 1;
} }
else if (!strcmp(argv[i], "-configfile")) { else if (!strcmp(argv[i], "-configfile")) {

4
hw/dmx/dmxpict.c
View File

@ -141,10 +141,6 @@ dmxPictureInit(ScreenPtr pScreen, PictFormatPtr formats, int nformats)
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum]; DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
PictureScreenPtr ps; PictureScreenPtr ps;
/* The shadow framebuffer only relies on FB to be initialized */
if (dmxShadowFB)
return fbPictureInit(pScreen, formats, nformats);
if (!miPictureInit(pScreen, formats, nformats)) if (!miPictureInit(pScreen, formats, nformats))
return FALSE; return FALSE;

239
hw/dmx/dmxscrinit.c
View File

@ -41,7 +41,6 @@
#include "dmx.h" #include "dmx.h"
#include "dmxsync.h" #include "dmxsync.h"
#include "dmxshadow.h"
#include "dmxscrinit.h" #include "dmxscrinit.h"
#include "dmxcursor.h" #include "dmxcursor.h"
#include "dmxgc.h" #include "dmxgc.h"
@ -159,37 +158,18 @@ dmxBEScreenInit(ScreenPtr pScreen)
XMapWindow(dmxScreen->beDisplay, dmxScreen->scrnWin); XMapWindow(dmxScreen->beDisplay, dmxScreen->scrnWin);
if (dmxShadowFB) { /* Create default drawables (used during GC creation) */
mask = (GCFunction | GCPlaneMask | GCClipMask); for (i = 0; i < dmxScreen->beNumPixmapFormats; i++)
gcvals.function = GXcopy; for (j = 0; j < dmxScreen->beNumDepths; j++)
gcvals.plane_mask = AllPlanes; if ((dmxScreen->bePixmapFormats[i].depth == 1) ||
gcvals.clip_mask = None; (dmxScreen->bePixmapFormats[i].depth ==
dmxScreen->beDepths[j])) {
dmxScreen->shadowGC = XCreateGC(dmxScreen->beDisplay, dmxScreen->scrnDefDrawables[i] = (Drawable)
dmxScreen->scrnWin, mask, &gcvals); XCreatePixmap(dmxScreen->beDisplay, dmxScreen->scrnWin,
1, 1,
dmxScreen->shadowFBImage = dmxScreen->bePixmapFormats[i].depth);
XCreateImage(dmxScreen->beDisplay, break;
dmxScreen->beVisuals[dmxScreen->beDefVisualIndex]. }
visual, dmxScreen->beDepth, ZPixmap, 0,
(char *) dmxScreen->shadow, dmxScreen->scrnWidth,
dmxScreen->scrnHeight, dmxScreen->beBPP,
PixmapBytePad(dmxScreen->scrnWidth, dmxScreen->beBPP));
}
else {
/* Create default drawables (used during GC creation) */
for (i = 0; i < dmxScreen->beNumPixmapFormats; i++)
for (j = 0; j < dmxScreen->beNumDepths; j++)
if ((dmxScreen->bePixmapFormats[i].depth == 1) ||
(dmxScreen->bePixmapFormats[i].depth ==
dmxScreen->beDepths[j])) {
dmxScreen->scrnDefDrawables[i] = (Drawable)
XCreatePixmap(dmxScreen->beDisplay, dmxScreen->scrnWin,
1, 1,
dmxScreen->bePixmapFormats[i].depth);
break;
}
}
} }
/** Initialize screen number \a pScreen->myNum. */ /** Initialize screen number \a pScreen->myNum. */
@ -215,19 +195,12 @@ dmxScreenInit(ScreenPtr pScreen, int argc, char *argv[])
dmxGeneration = serverGeneration; dmxGeneration = serverGeneration;
} }
if (dmxShadowFB) { if (!dmxInitGC(pScreen))
dmxScreen->shadow = shadowAlloc(dmxScreen->scrnWidth, return FALSE;
dmxScreen->scrnHeight, if (!dmxInitWindow(pScreen))
dmxScreen->beBPP); return FALSE;
} if (!dmxInitPixmap(pScreen))
else { return FALSE;
if (!dmxInitGC(pScreen))
return FALSE;
if (!dmxInitWindow(pScreen))
return FALSE;
if (!dmxInitPixmap(pScreen))
return FALSE;
}
/* /*
* Initalise the visual types. miSetVisualTypesAndMasks() requires * Initalise the visual types. miSetVisualTypesAndMasks() requires
@ -267,7 +240,7 @@ dmxScreenInit(ScreenPtr pScreen, int argc, char *argv[])
} }
fbScreenInit(pScreen, fbScreenInit(pScreen,
dmxShadowFB ? dmxScreen->shadow : NULL, NULL,
dmxScreen->scrnWidth, dmxScreen->scrnWidth,
dmxScreen->scrnHeight, dmxScreen->scrnHeight,
dmxScreen->beXDPI, dmxScreen->beXDPI,
@ -278,22 +251,14 @@ dmxScreenInit(ScreenPtr pScreen, int argc, char *argv[])
pScreen->GetWindowPixmap = NULL; pScreen->GetWindowPixmap = NULL;
pScreen->SetWindowPixmap = NULL; pScreen->SetWindowPixmap = NULL;
if (dmxShadowFB && !shadowInit(pScreen, dmxShadowUpdateProc, NULL)) MAXSCREENSALLOC(dmxCursorGeneration);
return FALSE; if (dmxCursorGeneration[pScreen->myNum] != serverGeneration) {
if (!(miPointerInitialize(pScreen,
&dmxPointerSpriteFuncs,
&dmxPointerCursorFuncs, FALSE)))
return FALSE;
if (dmxShadowFB) { dmxCursorGeneration[pScreen->myNum] = serverGeneration;
miDCInitialize(pScreen, &dmxPointerCursorFuncs);
}
else {
MAXSCREENSALLOC(dmxCursorGeneration);
if (dmxCursorGeneration[pScreen->myNum] != serverGeneration) {
if (!(miPointerInitialize(pScreen,
&dmxPointerSpriteFuncs,
&dmxPointerCursorFuncs, FALSE)))
return FALSE;
dmxCursorGeneration[pScreen->myNum] = serverGeneration;
}
} }
DMX_WRAP(CloseScreen, dmxCloseScreen, dmxScreen, pScreen); DMX_WRAP(CloseScreen, dmxCloseScreen, dmxScreen, pScreen);
@ -301,49 +266,47 @@ dmxScreenInit(ScreenPtr pScreen, int argc, char *argv[])
dmxBEScreenInit(pScreen); dmxBEScreenInit(pScreen);
if (!dmxShadowFB) { /* Wrap GC functions */
/* Wrap GC functions */ DMX_WRAP(CreateGC, dmxCreateGC, dmxScreen, pScreen);
DMX_WRAP(CreateGC, dmxCreateGC, dmxScreen, pScreen);
/* Wrap Window functions */ /* Wrap Window functions */
DMX_WRAP(CreateWindow, dmxCreateWindow, dmxScreen, pScreen); DMX_WRAP(CreateWindow, dmxCreateWindow, dmxScreen, pScreen);
DMX_WRAP(DestroyWindow, dmxDestroyWindow, dmxScreen, pScreen); DMX_WRAP(DestroyWindow, dmxDestroyWindow, dmxScreen, pScreen);
DMX_WRAP(PositionWindow, dmxPositionWindow, dmxScreen, pScreen); DMX_WRAP(PositionWindow, dmxPositionWindow, dmxScreen, pScreen);
DMX_WRAP(ChangeWindowAttributes, dmxChangeWindowAttributes, dmxScreen, DMX_WRAP(ChangeWindowAttributes, dmxChangeWindowAttributes, dmxScreen,
pScreen); pScreen);
DMX_WRAP(RealizeWindow, dmxRealizeWindow, dmxScreen, pScreen); DMX_WRAP(RealizeWindow, dmxRealizeWindow, dmxScreen, pScreen);
DMX_WRAP(UnrealizeWindow, dmxUnrealizeWindow, dmxScreen, pScreen); DMX_WRAP(UnrealizeWindow, dmxUnrealizeWindow, dmxScreen, pScreen);
DMX_WRAP(RestackWindow, dmxRestackWindow, dmxScreen, pScreen); DMX_WRAP(RestackWindow, dmxRestackWindow, dmxScreen, pScreen);
DMX_WRAP(WindowExposures, dmxWindowExposures, dmxScreen, pScreen); DMX_WRAP(WindowExposures, dmxWindowExposures, dmxScreen, pScreen);
DMX_WRAP(CopyWindow, dmxCopyWindow, dmxScreen, pScreen); DMX_WRAP(CopyWindow, dmxCopyWindow, dmxScreen, pScreen);
DMX_WRAP(ResizeWindow, dmxResizeWindow, dmxScreen, pScreen); DMX_WRAP(ResizeWindow, dmxResizeWindow, dmxScreen, pScreen);
DMX_WRAP(ReparentWindow, dmxReparentWindow, dmxScreen, pScreen); DMX_WRAP(ReparentWindow, dmxReparentWindow, dmxScreen, pScreen);
DMX_WRAP(ChangeBorderWidth, dmxChangeBorderWidth, dmxScreen, pScreen); DMX_WRAP(ChangeBorderWidth, dmxChangeBorderWidth, dmxScreen, pScreen);
/* Wrap Image functions */ /* Wrap Image functions */
DMX_WRAP(GetImage, dmxGetImage, dmxScreen, pScreen); DMX_WRAP(GetImage, dmxGetImage, dmxScreen, pScreen);
DMX_WRAP(GetSpans, dmxGetSpans, dmxScreen, pScreen); DMX_WRAP(GetSpans, dmxGetSpans, dmxScreen, pScreen);
/* Wrap Pixmap functions */ /* Wrap Pixmap functions */
DMX_WRAP(CreatePixmap, dmxCreatePixmap, dmxScreen, pScreen); DMX_WRAP(CreatePixmap, dmxCreatePixmap, dmxScreen, pScreen);
DMX_WRAP(DestroyPixmap, dmxDestroyPixmap, dmxScreen, pScreen); DMX_WRAP(DestroyPixmap, dmxDestroyPixmap, dmxScreen, pScreen);
DMX_WRAP(BitmapToRegion, dmxBitmapToRegion, dmxScreen, pScreen); DMX_WRAP(BitmapToRegion, dmxBitmapToRegion, dmxScreen, pScreen);
/* Wrap Font functions */ /* Wrap Font functions */
DMX_WRAP(RealizeFont, dmxRealizeFont, dmxScreen, pScreen); DMX_WRAP(RealizeFont, dmxRealizeFont, dmxScreen, pScreen);
DMX_WRAP(UnrealizeFont, dmxUnrealizeFont, dmxScreen, pScreen); DMX_WRAP(UnrealizeFont, dmxUnrealizeFont, dmxScreen, pScreen);
/* Wrap Colormap functions */ /* Wrap Colormap functions */
DMX_WRAP(CreateColormap, dmxCreateColormap, dmxScreen, pScreen); DMX_WRAP(CreateColormap, dmxCreateColormap, dmxScreen, pScreen);
DMX_WRAP(DestroyColormap, dmxDestroyColormap, dmxScreen, pScreen); DMX_WRAP(DestroyColormap, dmxDestroyColormap, dmxScreen, pScreen);
DMX_WRAP(InstallColormap, dmxInstallColormap, dmxScreen, pScreen); DMX_WRAP(InstallColormap, dmxInstallColormap, dmxScreen, pScreen);
DMX_WRAP(StoreColors, dmxStoreColors, dmxScreen, pScreen); DMX_WRAP(StoreColors, dmxStoreColors, dmxScreen, pScreen);
/* Wrap Shape functions */ /* Wrap Shape functions */
DMX_WRAP(SetShape, dmxSetShape, dmxScreen, pScreen); DMX_WRAP(SetShape, dmxSetShape, dmxScreen, pScreen);
}
if (!dmxCreateDefColormap(pScreen)) if (!dmxCreateDefColormap(pScreen))
return FALSE; return FALSE;
@ -370,22 +333,13 @@ dmxBECloseScreen(ScreenPtr pScreen)
XDestroyWindow(dmxScreen->beDisplay, dmxScreen->scrnWin); XDestroyWindow(dmxScreen->beDisplay, dmxScreen->scrnWin);
dmxScreen->scrnWin = (Window) 0; dmxScreen->scrnWin = (Window) 0;
if (dmxShadowFB) { /* Free the default drawables */
/* Free the shadow GC and image assocated with the back-end server */ for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {
XFreeGC(dmxScreen->beDisplay, dmxScreen->shadowGC); if (dmxScreen->scrnDefDrawables[i]) {
dmxScreen->shadowGC = NULL; XFreePixmap(dmxScreen->beDisplay,
XFree(dmxScreen->shadowFBImage); dmxScreen->scrnDefDrawables[i]);
dmxScreen->shadowFBImage = NULL; dmxScreen->scrnDefDrawables[i] = (Drawable) 0;
} }
else {
/* Free the default drawables */
for (i = 0; i < dmxScreen->beNumPixmapFormats; i++) {
if (dmxScreen->scrnDefDrawables[i]) {
XFreePixmap(dmxScreen->beDisplay,
dmxScreen->scrnDefDrawables[i]);
dmxScreen->scrnDefDrawables[i] = (Drawable) 0;
}
}
} }
/* Free resources allocated during initialization (in dmxinit.c) */ /* Free resources allocated during initialization (in dmxinit.c) */
@ -432,48 +386,41 @@ dmxCloseScreen(ScreenPtr pScreen)
dmxResetFonts(); dmxResetFonts();
} }
if (dmxShadowFB) { /* Unwrap Shape functions */
/* Free the shadow framebuffer */ DMX_UNWRAP(SetShape, dmxScreen, pScreen);
free(dmxScreen->shadow);
}
else {
/* Unwrap Shape functions */ /* Unwrap the pScreen functions */
DMX_UNWRAP(SetShape, dmxScreen, pScreen); DMX_UNWRAP(CreateGC, dmxScreen, pScreen);
/* Unwrap the pScreen functions */ DMX_UNWRAP(CreateWindow, dmxScreen, pScreen);
DMX_UNWRAP(CreateGC, dmxScreen, pScreen); DMX_UNWRAP(DestroyWindow, dmxScreen, pScreen);
DMX_UNWRAP(PositionWindow, dmxScreen, pScreen);
DMX_UNWRAP(ChangeWindowAttributes, dmxScreen, pScreen);
DMX_UNWRAP(RealizeWindow, dmxScreen, pScreen);
DMX_UNWRAP(UnrealizeWindow, dmxScreen, pScreen);
DMX_UNWRAP(RestackWindow, dmxScreen, pScreen);
DMX_UNWRAP(WindowExposures, dmxScreen, pScreen);
DMX_UNWRAP(CopyWindow, dmxScreen, pScreen);
DMX_UNWRAP(CreateWindow, dmxScreen, pScreen); DMX_UNWRAP(ResizeWindow, dmxScreen, pScreen);
DMX_UNWRAP(DestroyWindow, dmxScreen, pScreen); DMX_UNWRAP(ReparentWindow, dmxScreen, pScreen);
DMX_UNWRAP(PositionWindow, dmxScreen, pScreen);
DMX_UNWRAP(ChangeWindowAttributes, dmxScreen, pScreen);
DMX_UNWRAP(RealizeWindow, dmxScreen, pScreen);
DMX_UNWRAP(UnrealizeWindow, dmxScreen, pScreen);
DMX_UNWRAP(RestackWindow, dmxScreen, pScreen);
DMX_UNWRAP(WindowExposures, dmxScreen, pScreen);
DMX_UNWRAP(CopyWindow, dmxScreen, pScreen);
DMX_UNWRAP(ResizeWindow, dmxScreen, pScreen); DMX_UNWRAP(ChangeBorderWidth, dmxScreen, pScreen);
DMX_UNWRAP(ReparentWindow, dmxScreen, pScreen);
DMX_UNWRAP(ChangeBorderWidth, dmxScreen, pScreen); DMX_UNWRAP(GetImage, dmxScreen, pScreen);
DMX_UNWRAP(GetSpans, dmxScreen, pScreen);
DMX_UNWRAP(GetImage, dmxScreen, pScreen); DMX_UNWRAP(CreatePixmap, dmxScreen, pScreen);
DMX_UNWRAP(GetSpans, dmxScreen, pScreen); DMX_UNWRAP(DestroyPixmap, dmxScreen, pScreen);
DMX_UNWRAP(BitmapToRegion, dmxScreen, pScreen);
DMX_UNWRAP(CreatePixmap, dmxScreen, pScreen); DMX_UNWRAP(RealizeFont, dmxScreen, pScreen);
DMX_UNWRAP(DestroyPixmap, dmxScreen, pScreen); DMX_UNWRAP(UnrealizeFont, dmxScreen, pScreen);
DMX_UNWRAP(BitmapToRegion, dmxScreen, pScreen);
DMX_UNWRAP(RealizeFont, dmxScreen, pScreen); DMX_UNWRAP(CreateColormap, dmxScreen, pScreen);
DMX_UNWRAP(UnrealizeFont, dmxScreen, pScreen); DMX_UNWRAP(DestroyColormap, dmxScreen, pScreen);
DMX_UNWRAP(InstallColormap, dmxScreen, pScreen);
DMX_UNWRAP(CreateColormap, dmxScreen, pScreen); DMX_UNWRAP(StoreColors, dmxScreen, pScreen);
DMX_UNWRAP(DestroyColormap, dmxScreen, pScreen);
DMX_UNWRAP(InstallColormap, dmxScreen, pScreen);
DMX_UNWRAP(StoreColors, dmxScreen, pScreen);
}
DMX_UNWRAP(SaveScreen, dmxScreen, pScreen); DMX_UNWRAP(SaveScreen, dmxScreen, pScreen);

70
hw/dmx/dmxshadow.c
View File

@ -1,70 +0,0 @@
/*
* Copyright 2001 Red Hat Inc., Durham, North Carolina.
*
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation on the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/*
* Authors:
* Kevin E. Martin <kem@redhat.com>
* David H. Dawes <dawes@xfree86.org>
*
*/
#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif
#include "dmx.h"
#include "dmxsync.h"
#include "dmxshadow.h"
/** \file
* This file provides support for the shadow frame buffer. */
/** Update the screen from the shadow frame buffer. */
void
dmxShadowUpdateProc(ScreenPtr pScreen, shadowBufPtr pBuf)
{
RegionPtr damage = &pBuf->damage;
int nbox = RegionNumRects(damage);
BoxPtr pbox = RegionRects(damage);
DMXScreenInfo *dmxScreen = &dmxScreens[pScreen->myNum];
if (!dmxScreen->beDisplay)
return;
while (nbox--) {
XPutImage(dmxScreen->beDisplay,
dmxScreen->scrnWin,
dmxScreen->shadowGC,
dmxScreen->shadowFBImage,
pbox->x1, pbox->y1,
pbox->x1, pbox->y1, pbox->x2 - pbox->x1, pbox->y2 - pbox->y1);
pbox++;
}
dmxSync(dmxScreen, FALSE);
}

46
hw/dmx/dmxshadow.h
View File

@ -1,46 +0,0 @@
/*
* Copyright 2001 Red Hat Inc., Durham, North Carolina.
*
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation on the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/*
* Authors:
* Kevin E. Martin <kem@redhat.com>
* David H. Dawes <dawes@xfree86.org>
*
*/
/** \file
* Interface for shadow framebuffer support. \see dmxshadow.c */
#ifndef DMXSHADOW_H
#define DMXSHADOW_H
#include "shadow.h"
#include "scrnintstr.h"
extern void dmxShadowUpdateProc(ScreenPtr pScreen, shadowBufPtr pBuf);
#endif /* DMXSHADOW_H */

5
hw/dmx/input/dmxcommon.c
View File

@ -502,11 +502,6 @@ dmxCommonMouOn(DevicePtr pDev)
GETDMXINPUTFROMPRIV; GETDMXINPUTFROMPRIV;
priv->eventMask |= DMX_POINTER_EVENT_MASK; priv->eventMask |= DMX_POINTER_EVENT_MASK;
if (dmxShadowFB) {
XWarpPointer(priv->display, priv->window, priv->window,
0, 0, 0, 0, priv->initPointerX, priv->initPointerY);
dmxSync(&dmxScreens[dmxInput->scrnIdx], TRUE);
}
if (!priv->be) { if (!priv->be) {
XSelectInput(priv->display, priv->window, priv->eventMask); XSelectInput(priv->display, priv->window, priv->eventMask);
AddEnabledDevice(XConnectionNumber(priv->display)); AddEnabledDevice(XConnectionNumber(priv->display));

10
hw/dmx/man/Xdmx.man
View File

@ -179,16 +179,6 @@ will switch to another VC in local (raw) mode.
.RE .RE
.sp .sp
.TP 8 .TP 8
.BI "-shadowfb"
This option turns on (legacy) support for the shadow frame buffer.
.sp
.TP 8
.BI "-noshadowfb"
This option turns off (legacy) support for the shadow frame buffer.
Note that this option has been deprecated and will be removed in the
next release.
.sp
.TP 8
.BI "-nomulticursor" .BI "-nomulticursor"
This option turns off support for displaying multiple cursors on This option turns off support for displaying multiple cursors on
overlapped back-end displays. This option is available for testing and overlapped back-end displays. This option is available for testing and