ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

A few simplifications and optimizations in the x11 driver.

This commit is contained in:
Alexandre Julliard 2000-03-25 14:05:06 +00:00
parent 77d5ebbb37
commit 9383eb94a7
18 changed files with 90 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
dlls/ddraw/ddraw_main.c
View File

@ -1017,8 +1017,8 @@ static HRESULT WINAPI Xlib_IDirectDrawSurface4Impl_SetPalette(
if( !(ipal->cm) && (This->s.ddraw->d.screen_pixelformat.u.dwRGBBitCount<=8)) if( !(ipal->cm) && (This->s.ddraw->d.screen_pixelformat.u.dwRGBBitCount<=8))
{ {
ipal->cm = TSXCreateColormap(display,This->s.ddraw->d.drawable, ipal->cm = TSXCreateColormap(display,This->s.ddraw->d.drawable,
DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll); X11DRV_GetVisual(),AllocAll);
if (!Options.managed) if (!Options.managed)
TSXInstallColormap(display,ipal->cm); TSXInstallColormap(display,ipal->cm);
@ -3228,8 +3228,7 @@ static XImage *create_xshmimage(IDirectDraw2Impl* This, IDirectDrawSurface4Impl*
XImage *img; XImage *img;
int (*WineXHandler)(Display *, XErrorEvent *); int (*WineXHandler)(Display *, XErrorEvent *);
img = TSXShmCreateImage(display, img = TSXShmCreateImage(display, X11DRV_GetVisual(),
DefaultVisualOfScreen(X11DRV_GetXScreen()),
This->d.pixmap_depth, This->d.pixmap_depth,
ZPixmap, ZPixmap,
NULL, NULL,
@ -3348,8 +3347,7 @@ static XImage *create_ximage(IDirectDraw2Impl* This, IDirectDrawSurface4Impl* lp
} }
/* In this case, create an XImage */ /* In this case, create an XImage */
img = TSXCreateImage(display, img = TSXCreateImage(display, X11DRV_GetVisual(),
DefaultVisualOfScreen(X11DRV_GetXScreen()),
This->d.pixmap_depth, This->d.pixmap_depth,
ZPixmap, ZPixmap,
0, 0,
@ -4268,7 +4266,7 @@ static HRESULT WINAPI DGA_IDirectDraw2Impl_CreatePalette(
if (res != 0) return res; if (res != 0) return res;
ICOM_VTBL(*ilpddpal) = &dga_ddpalvt; ICOM_VTBL(*ilpddpal) = &dga_ddpalvt;
if (This->d.directdraw_pixelformat.u.dwRGBBitCount<=8) { if (This->d.directdraw_pixelformat.u.dwRGBBitCount<=8) {
(*ilpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),DefaultVisualOfScreen(X11DRV_GetXScreen()),AllocAll); (*ilpddpal)->cm = TSXCreateColormap(display,DefaultRootWindow(display),X11DRV_GetVisual(),AllocAll);
} else { } else {
FIXME("why are we doing CreatePalette in hi/truecolor?\n"); FIXME("why are we doing CreatePalette in hi/truecolor?\n");
(*ilpddpal)->cm = 0; (*ilpddpal)->cm = 0;
@ -5377,7 +5375,6 @@ static HRESULT WINAPI DGA_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnk
IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD; IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
int memsize,banksize,major,minor,flags; int memsize,banksize,major,minor,flags;
char *addr; char *addr;
int depth;
int dga_version; int dga_version;
int width, height; int width, height;
@ -5423,8 +5420,8 @@ static HRESULT WINAPI DGA_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnk
(*ilplpDD)->e.dga.vpmask = 0; (*ilplpDD)->e.dga.vpmask = 0;
/* just assume the default depth is the DGA depth too */ /* just assume the default depth is the DGA depth too */
depth = DefaultDepthOfScreen(X11DRV_GetXScreen()); _common_depth_to_pixelformat(X11DRV_GetDepth(), &((*ilplpDD)->d.directdraw_pixelformat),
_common_depth_to_pixelformat(depth, &((*ilplpDD)->d.directdraw_pixelformat), &((*ilplpDD)->d.screen_pixelformat), NULL); &((*ilplpDD)->d.screen_pixelformat), NULL);
#ifdef RESTORE_SIGNALS #ifdef RESTORE_SIGNALS
SIGNAL_Init(); SIGNAL_Init();
#endif #endif
@ -5510,7 +5507,6 @@ DDRAW_XSHM_Available(void)
static HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) { static HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUnkOuter) {
IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD; IDirectDrawImpl** ilplpDD=(IDirectDrawImpl**)lplpDD;
int depth;
*ilplpDD = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawImpl)); *ilplpDD = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectDrawImpl));
ICOM_VTBL(*ilplpDD) = &xlib_ddvt; ICOM_VTBL(*ilplpDD) = &xlib_ddvt;
@ -5518,8 +5514,7 @@ static HRESULT WINAPI Xlib_DirectDrawCreate( LPDIRECTDRAW *lplpDD, LPUNKNOWN pUn
(*ilplpDD)->d.drawable = 0; /* in SetDisplayMode */ (*ilplpDD)->d.drawable = 0; /* in SetDisplayMode */
/* At DirectDraw creation, the depth is the default depth */ /* At DirectDraw creation, the depth is the default depth */
depth = DefaultDepthOfScreen(X11DRV_GetXScreen()); _common_depth_to_pixelformat(X11DRV_GetDepth(),
_common_depth_to_pixelformat(depth,
&((*ilplpDD)->d.directdraw_pixelformat), &((*ilplpDD)->d.directdraw_pixelformat),
&((*ilplpDD)->d.screen_pixelformat), &((*ilplpDD)->d.screen_pixelformat),
&((*ilplpDD)->d.pixmap_depth)); &((*ilplpDD)->d.pixmap_depth));

25
dlls/x11drv/x11drv_main.c
View File

@ -50,6 +50,10 @@ static USER_DRIVER user_driver =
static XKeyboardState keyboard_state; static XKeyboardState keyboard_state;
Display *display; Display *display;
Screen *screen;
Visual *visual;
int screen_depth;
Window root_window;
/*********************************************************************** /***********************************************************************
* error_handler * error_handler
@ -85,6 +89,27 @@ static void process_attach(void)
argv0, Options.display ? Options.display : "(none specified)" ); argv0, Options.display ? Options.display : "(none specified)" );
ExitProcess(1); ExitProcess(1);
} }
screen = DefaultScreenOfDisplay( display );
visual = DefaultVisual( display, DefaultScreen(display) );
root_window = DefaultRootWindow( display );
/* Initialize screen depth */
screen_depth = PROFILE_GetWineIniInt( "x11drv", "ScreenDepth", 0 );
if (screen_depth) /* depth specified */
{
int depth_count, i;
int *depth_list = TSXListDepths(display, DefaultScreen(display), &depth_count);
for (i = 0; i < depth_count; i++)
if (depth_list[i] == screen_depth) break;
TSXFree( depth_list );
if (i >= depth_count)
{
MESSAGE( "%s: Depth %d not supported on this screen.\n", argv0, screen_depth );
ExitProcess(1);
}
}
else screen_depth = DefaultDepthOfScreen( screen );
/* tell the libX11 that we will do input method handling ourselves /* tell the libX11 that we will do input method handling ourselves
* that keep libX11 from doing anything whith dead keys, allowing Wine * that keep libX11 from doing anything whith dead keys, allowing Wine

17
graphics/x11drv/bitmap.c
View File

@ -19,7 +19,6 @@
#include "dc.h" #include "dc.h"
#include "bitmap.h" #include "bitmap.h"
#include "heap.h" #include "heap.h"
#include "monitor.h"
#include "debugtools.h" #include "debugtools.h"
#include "xmalloc.h" #include "xmalloc.h"
#include "local.h" #include "local.h"
@ -28,7 +27,7 @@
#include "windef.h" #include "windef.h"
#include "wine/winuser16.h" #include "wine/winuser16.h"
DEFAULT_DEBUG_CHANNEL(x11drv) DEFAULT_DEBUG_CHANNEL(x11drv);
/* GCs used for B&W and color bitmap operations */ /* GCs used for B&W and color bitmap operations */
GC BITMAP_monoGC = 0, BITMAP_colorGC = 0; GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
@ -53,12 +52,10 @@ BOOL X11DRV_BITMAP_Init(void)
TSXFreePixmap( display, tmpPixmap ); TSXFreePixmap( display, tmpPixmap );
} }
if (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) != 1) if (X11DRV_GetDepth() != 1)
{ {
if ((tmpPixmap = TSXCreatePixmap(display, if ((tmpPixmap = TSXCreatePixmap(display, X11DRV_GetXRootWindow(),
X11DRV_GetXRootWindow(), 1, 1, X11DRV_GetDepth())))
1, 1,
MONITOR_GetDepth(&MONITOR_PrimaryMonitor))))
{ {
BITMAP_colorGC = TSXCreateGC( display, tmpPixmap, 0, NULL ); BITMAP_colorGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
TSXSetGraphicsExposures( display, BITMAP_colorGC, False ); TSXSetGraphicsExposures( display, BITMAP_colorGC, False );
@ -200,7 +197,8 @@ BOOL X11DRV_CreateBitmap( HBITMAP hbitmap )
/* Check parameters */ /* Check parameters */
if (bmp->bitmap.bmPlanes != 1) return 0; if (bmp->bitmap.bmPlanes != 1) return 0;
if ((bmp->bitmap.bmBitsPixel != 1) && if ((bmp->bitmap.bmBitsPixel != 1) &&
(bmp->bitmap.bmBitsPixel != MONITOR_GetDepth(&MONITOR_PrimaryMonitor))) { (bmp->bitmap.bmBitsPixel != X11DRV_GetDepth()))
{
ERR("Trying to make bitmap with planes=%d, bpp=%d\n", ERR("Trying to make bitmap with planes=%d, bpp=%d\n",
bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel); bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel);
GDI_HEAP_UNLOCK( hbitmap ); GDI_HEAP_UNLOCK( hbitmap );
@ -395,8 +393,7 @@ static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
height = count / bmp->bitmap.bmWidthBytes; height = count / bmp->bitmap.bmWidthBytes;
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );
image = XCreateImage( display, DefaultVisualOfScreen(X11DRV_GetXScreen()), image = XCreateImage( display, X11DRV_GetVisual(), bmp->bitmap.bmBitsPixel, ZPixmap, 0, NULL,
bmp->bitmap.bmBitsPixel, ZPixmap, 0, NULL,
bmp->bitmap.bmWidth, height, 32, 0 ); bmp->bitmap.bmWidth, height, 32, 0 );
image->data = (LPBYTE)xmalloc(image->bytes_per_line * height); image->data = (LPBYTE)xmalloc(image->bytes_per_line * height);

9
graphics/x11drv/brush.c
View File

@ -16,10 +16,9 @@
#include "color.h" #include "color.h"
#include "x11drv.h" #include "x11drv.h"
#include "debugtools.h" #include "debugtools.h"
#include "monitor.h"
#include "local.h" #include "local.h"
DEFAULT_DEBUG_CHANNEL(gdi) DEFAULT_DEBUG_CHANNEL(gdi);
static const char HatchBrushes[NB_HATCH_STYLES + 1][8] = static const char HatchBrushes[NB_HATCH_STYLES + 1][8] =
{ {
@ -102,7 +101,7 @@ static XImage *ditherImage = NULL;
*/ */
BOOL X11DRV_BRUSH_Init(void) BOOL X11DRV_BRUSH_Init(void)
{ {
XCREATEIMAGE( ditherImage, MATRIX_SIZE, MATRIX_SIZE, MONITOR_GetDepth(&MONITOR_PrimaryMonitor) ); XCREATEIMAGE( ditherImage, MATRIX_SIZE, MATRIX_SIZE, X11DRV_GetDepth() );
return (ditherImage != NULL); return (ditherImage != NULL);
} }
@ -139,7 +138,7 @@ static Pixmap BRUSH_DitherColor( DC *dc, COLORREF color )
} }
pixmap = XCreatePixmap( display, X11DRV_GetXRootWindow(), pixmap = XCreatePixmap( display, X11DRV_GetXRootWindow(),
MATRIX_SIZE, MATRIX_SIZE, MONITOR_GetDepth(&MONITOR_PrimaryMonitor) ); MATRIX_SIZE, MATRIX_SIZE, X11DRV_GetDepth() );
XPutImage( display, pixmap, BITMAP_colorGC, ditherImage, 0, 0, XPutImage( display, pixmap, BITMAP_colorGC, ditherImage, 0, 0,
0, 0, MATRIX_SIZE, MATRIX_SIZE ); 0, 0, MATRIX_SIZE, MATRIX_SIZE );
LeaveCriticalSection( &X11DRV_CritSection ); LeaveCriticalSection( &X11DRV_CritSection );
@ -154,7 +153,7 @@ static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color )
{ {
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev; X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
if ((dc->w.bitsPerPixel > 1) && (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8) && !COLOR_IsSolid( color )) if ((dc->w.bitsPerPixel > 1) && (X11DRV_GetDepth() <= 8) && !COLOR_IsSolid( color ))
{ {
/* Dithered brush */ /* Dithered brush */
physDev->brush.pixmap = BRUSH_DitherColor( dc, color ); physDev->brush.pixmap = BRUSH_DitherColor( dc, color );

13
graphics/x11drv/dib.c
View File

@ -50,7 +50,7 @@ BOOL X11DRV_DIB_Init(void)
for( i = 0; bitmapDepthTable[i]; i++ ) for( i = 0; bitmapDepthTable[i]; i++ )
{ {
testimage = TSXCreateImage(display, DefaultVisualOfScreen(X11DRV_GetXScreen()), testimage = TSXCreateImage(display, X11DRV_GetVisual(),
bitmapDepthTable[i], ZPixmap, 0, NULL, 1, 1, 32, 20 ); bitmapDepthTable[i], ZPixmap, 0, NULL, 1, 1, 32, 20 );
if( testimage ) ximageDepthTable[i] = testimage->bits_per_pixel; if( testimage ) ximageDepthTable[i] = testimage->bits_per_pixel;
else return FALSE; else return FALSE;
@ -2506,9 +2506,7 @@ int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
if (descr->image) if (descr->image)
bmpImage = descr->image; bmpImage = descr->image;
else { else {
bmpImage = XCreateImage( display, bmpImage = XCreateImage( display, X11DRV_GetVisual(), descr->depth, ZPixmap, 0, NULL,
DefaultVisualOfScreen(X11DRV_GetXScreen()),
descr->depth, ZPixmap, 0, NULL,
descr->infoWidth, lines, 32, 0 ); descr->infoWidth, lines, 32, 0 );
bmpImage->data = calloc( lines, bmpImage->bytes_per_line ); bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
if(bmpImage->data == NULL) { if(bmpImage->data == NULL) {
@ -2611,9 +2609,7 @@ int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
if (descr->image) if (descr->image)
bmpImage = descr->image; bmpImage = descr->image;
else { else {
bmpImage = XCreateImage( display, bmpImage = XCreateImage( display, X11DRV_GetVisual(), descr->depth, ZPixmap, 0, NULL,
DefaultVisualOfScreen(X11DRV_GetXScreen()),
descr->depth, ZPixmap, 0, NULL,
descr->infoWidth, lines, 32, 0 ); descr->infoWidth, lines, 32, 0 );
bmpImage->data = calloc( lines, bmpImage->bytes_per_line ); bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
if(bmpImage->data == NULL) { if(bmpImage->data == NULL) {
@ -3232,8 +3228,7 @@ extern BOOL X11DRV_XShmCreateImage(XImage** image, int width, int height, int bp
{ {
int (*WineXHandler)(Display *, XErrorEvent *); int (*WineXHandler)(Display *, XErrorEvent *);
*image = TSXShmCreateImage(display, DefaultVisualOfScreen(X11DRV_GetXScreen()), *image = TSXShmCreateImage(display, X11DRV_GetVisual(), bpp, ZPixmap, NULL, shminfo, width, height);
bpp, ZPixmap, NULL, shminfo, width, height);
if( *image != NULL ) if( *image != NULL )
{ {
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );

9
graphics/x11drv/graphics.c
View File

@ -32,7 +32,6 @@
#include "bitmap.h" #include "bitmap.h"
#include "gdi.h" #include "gdi.h"
#include "dc.h" #include "dc.h"
#include "monitor.h"
#include "callback.h" #include "callback.h"
#include "metafile.h" #include "metafile.h"
#include "palette.h" #include "palette.h"
@ -41,7 +40,7 @@
#include "struct32.h" #include "struct32.h"
#include "debugtools.h" #include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(graphics) DEFAULT_DEBUG_CHANNEL(graphics);
#define ABS(x) ((x)<0?(-(x)):(x)) #define ABS(x) ((x)<0?(-(x)):(x))
@ -131,10 +130,8 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors )
register int x, y; register int x, y;
XImage *image; XImage *image;
EnterCriticalSection( &X11DRV_CritSection ); EnterCriticalSection( &X11DRV_CritSection );
pixmap = XCreatePixmap( display, pixmap = XCreatePixmap( display, X11DRV_GetXRootWindow(),
X11DRV_GetXRootWindow(), 8, 8, X11DRV_GetDepth() );
8, 8,
MONITOR_GetDepth(&MONITOR_PrimaryMonitor) );
image = XGetImage( display, physDev->brush.pixmap, 0, 0, 8, 8, image = XGetImage( display, physDev->brush.pixmap, 0, 0, 8, 8,
AllPlanes, ZPixmap ); AllPlanes, ZPixmap );
for (y = 0; y < 8; y++) for (y = 0; y < 8; y++)

4
graphics/x11drv/init.c
View File

@ -191,7 +191,7 @@ BOOL X11DRV_GDI_Initialize(void)
X11DRV_DevCaps.vertSize = HeightMMOfScreen(X11DRV_GetXScreen()) * MONITOR_GetHeight(&MONITOR_PrimaryMonitor) / HeightOfScreen(X11DRV_GetXScreen()); X11DRV_DevCaps.vertSize = HeightMMOfScreen(X11DRV_GetXScreen()) * MONITOR_GetHeight(&MONITOR_PrimaryMonitor) / HeightOfScreen(X11DRV_GetXScreen());
X11DRV_DevCaps.horzRes = MONITOR_GetWidth(&MONITOR_PrimaryMonitor); X11DRV_DevCaps.horzRes = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
X11DRV_DevCaps.vertRes = MONITOR_GetHeight(&MONITOR_PrimaryMonitor); X11DRV_DevCaps.vertRes = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
X11DRV_DevCaps.bitsPixel = MONITOR_GetDepth(&MONITOR_PrimaryMonitor); X11DRV_DevCaps.bitsPixel = X11DRV_GetDepth();
/* Resolution will be adjusted during the font init */ /* Resolution will be adjusted during the font init */
@ -260,7 +260,7 @@ static BOOL X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
{ {
physDev->drawable = X11DRV_GetXRootWindow(); physDev->drawable = X11DRV_GetXRootWindow();
physDev->gc = TSXCreateGC( display, physDev->drawable, 0, NULL ); physDev->gc = TSXCreateGC( display, physDev->drawable, 0, NULL );
dc->w.bitsPerPixel = MONITOR_GetDepth(&MONITOR_PrimaryMonitor); dc->w.bitsPerPixel = X11DRV_GetDepth();
dc->w.totalExtent.left = 0; dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0; dc->w.totalExtent.top = 0;

3
graphics/x11drv/oembitmap.c
View File

@ -29,7 +29,6 @@ typedef unsigned long Pixel;
#include "gdi.h" #include "gdi.h"
#include "heap.h" #include "heap.h"
#include "local.h" #include "local.h"
#include "monitor.h"
#include "tweak.h" #include "tweak.h"
#include "x11drv.h" #include "x11drv.h"
@ -392,7 +391,7 @@ static BOOL OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr )
XpmAttributesSize() ); XpmAttributesSize() );
attrs->valuemask = XpmColormap | XpmDepth | XpmColorSymbols |XpmHotspot; attrs->valuemask = XpmColormap | XpmDepth | XpmColorSymbols |XpmHotspot;
attrs->colormap = X11DRV_PALETTE_PaletteXColormap; attrs->colormap = X11DRV_PALETTE_PaletteXColormap;
attrs->depth = descr->color ? MONITOR_GetDepth(&MONITOR_PrimaryMonitor) : 1; attrs->depth = descr->color ? X11DRV_GetDepth() : 1;
attrs->colorsymbols = (attrs->depth > 1) ? OBM_Colors : OBM_BlackAndWhite; attrs->colorsymbols = (attrs->depth > 1) ? OBM_Colors : OBM_BlackAndWhite;
attrs->numsymbols = (attrs->depth > 1) ? NB_COLOR_SYMBOLS : 2; attrs->numsymbols = (attrs->depth > 1) ? NB_COLOR_SYMBOLS : 2;

15
graphics/x11drv/palette.c
View File

@ -17,7 +17,6 @@
#include "color.h" #include "color.h"
#include "debugtools.h" #include "debugtools.h"
#include "gdi.h" #include "gdi.h"
#include "monitor.h"
#include "options.h" #include "options.h"
#include "palette.h" #include "palette.h"
#include "windef.h" #include "windef.h"
@ -102,7 +101,7 @@ BOOL X11DRV_PALETTE_Init(void)
int mask, white, black; int mask, white, black;
int monoPlane; int monoPlane;
Visual *visual = DefaultVisual( display, DefaultScreen(display) ); Visual *visual = X11DRV_GetVisual();
TRACE("initializing palette manager...\n"); TRACE("initializing palette manager...\n");
@ -149,7 +148,7 @@ BOOL X11DRV_PALETTE_Init(void)
case StaticGray: case StaticGray:
X11DRV_PALETTE_PaletteXColormap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); X11DRV_PALETTE_PaletteXColormap = DefaultColormapOfScreen( X11DRV_GetXScreen() );
X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_FIXED; X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_FIXED;
X11DRV_PALETTE_Graymax = (1<<MONITOR_GetDepth(&MONITOR_PrimaryMonitor))-1; X11DRV_PALETTE_Graymax = (1 << X11DRV_GetDepth())-1;
break; break;
case TrueColor: case TrueColor:
@ -343,7 +342,7 @@ static BOOL X11DRV_PALETTE_BuildSharedMap(void)
bp = BlackPixel(display, DefaultScreen(display)); bp = BlackPixel(display, DefaultScreen(display));
wp = WhitePixel(display, DefaultScreen(display)); wp = WhitePixel(display, DefaultScreen(display));
max = (0xffffffff)>>(32 - MONITOR_GetDepth(&MONITOR_PrimaryMonitor)); max = (0xffffffff)>>(32 - X11DRV_GetDepth());
if( max > 256 ) if( max > 256 )
{ {
step = max/256; step = max/256;
@ -444,7 +443,7 @@ static BOOL X11DRV_PALETTE_BuildSharedMap(void)
* to maintain compatibility * to maintain compatibility
*/ */
X11DRV_DevCaps.sizePalette = 256; X11DRV_DevCaps.sizePalette = 256;
TRACE("Virtual colorspace - screendepth %i\n", MONITOR_GetDepth(&MONITOR_PrimaryMonitor)); TRACE("Virtual colorspace - screendepth %i\n", X11DRV_GetDepth());
} }
else X11DRV_DevCaps.sizePalette = NB_RESERVED_COLORS; /* system palette only - however we can alloc a bunch else X11DRV_DevCaps.sizePalette = NB_RESERVED_COLORS; /* system palette only - however we can alloc a bunch
* of colors and map to them */ * of colors and map to them */
@ -471,7 +470,7 @@ static BOOL X11DRV_PALETTE_BuildSharedMap(void)
/* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */ /* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */
if( MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8 ) if (X11DRV_GetDepth() <= 8)
{ {
X11DRV_PALETTE_XPixelToPalette = (int*)calloc(256, sizeof(int)); X11DRV_PALETTE_XPixelToPalette = (int*)calloc(256, sizeof(int));
if(X11DRV_PALETTE_XPixelToPalette == NULL) { if(X11DRV_PALETTE_XPixelToPalette == NULL) {
@ -632,7 +631,7 @@ COLORREF X11DRV_PALETTE_ToLogical(int pixel)
#if 0 #if 0
/* truecolor visual */ /* truecolor visual */
if (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) >= 24) return pixel; if (X11DRV_GetDepth() >= 24) return pixel;
#endif #endif
/* check for hicolor visuals first */ /* check for hicolor visuals first */
@ -649,7 +648,7 @@ COLORREF X11DRV_PALETTE_ToLogical(int pixel)
/* check if we can bypass X */ /* check if we can bypass X */
if ((MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8) && (pixel < 256) && if ((X11DRV_GetDepth() <= 8) && (pixel < 256) &&
!(X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_VIRTUAL | X11DRV_PALETTE_FIXED)) ) !(X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_VIRTUAL | X11DRV_PALETTE_FIXED)) )
return ( *(COLORREF*)(COLOR_sysPal + return ( *(COLORREF*)(COLOR_sysPal +
((X11DRV_PALETTE_XPixelToPalette)?X11DRV_PALETTE_XPixelToPalette[pixel]:pixel)) ) & 0x00ffffff; ((X11DRV_PALETTE_XPixelToPalette)?X11DRV_PALETTE_XPixelToPalette[pixel]:pixel)) ) & 0x00ffffff;

28
include/x11drv.h
View File

@ -191,7 +191,7 @@ extern void _XInitImageFuncPtrs(XImage *);
#define XCREATEIMAGE(image,width,height,bpp) \ #define XCREATEIMAGE(image,width,height,bpp) \
{ \ { \
int width_bytes = X11DRV_DIB_GetXImageWidthBytes( (width), (bpp) ); \ int width_bytes = X11DRV_DIB_GetXImageWidthBytes( (width), (bpp) ); \
(image) = TSXCreateImage(display, DefaultVisualOfScreen(X11DRV_GetXScreen()), \ (image) = TSXCreateImage(display, X11DRV_GetVisual(), \
(bpp), ZPixmap, 0, calloc( (height), width_bytes ),\ (bpp), ZPixmap, 0, calloc( (height), width_bytes ),\
(width), (height), 32, width_bytes ); \ (width), (height), 32, width_bytes ); \
} }
@ -311,8 +311,15 @@ extern BOOL X11DRV_PALETTE_IsDark(int pixel);
*/ */
extern Display *display; extern Display *display;
extern Screen *X11DRV_GetXScreen(void); extern Screen *screen;
extern Window X11DRV_GetXRootWindow(void); extern Visual *visual;
extern Window root_window;
extern int screen_depth;
static inline Screen *X11DRV_GetXScreen(void) { return screen; }
static inline Visual *X11DRV_GetVisual(void) { return visual; }
static inline Window X11DRV_GetXRootWindow(void) { return root_window; }
static inline int X11DRV_GetDepth(void) { return screen_depth; }
/* X11 clipboard driver */ /* X11 clipboard driver */
@ -334,13 +341,6 @@ extern Atom X11DRV_CLIPBOARD_MapFormatToProperty(UINT id);
extern void X11DRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar); extern void X11DRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar);
extern void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd); extern void X11DRV_CLIPBOARD_ReleaseSelection(Atom selType, Window w, HWND hwnd);
/* X11 desktop driver */
struct tagDESKTOP;
extern Screen *X11DRV_DESKTOP_GetXScreen(struct tagDESKTOP *pDesktop);
extern Window X11DRV_DESKTOP_GetXRootWindow(struct tagDESKTOP *pDesktop);
/* X11 event driver */ /* X11 event driver */
extern WORD X11DRV_EVENT_XStateToKeyState( int state ) ; extern WORD X11DRV_EVENT_XStateToKeyState( int state ) ;
@ -383,18 +383,12 @@ extern void X11DRV_KEYBOARD_HandleEvent(struct tagWND *pWnd, XKeyEvent *event);
extern struct tagMONITOR_DRIVER X11DRV_MONITOR_Driver; extern struct tagMONITOR_DRIVER X11DRV_MONITOR_Driver;
typedef struct _X11DRV_MONITOR_DATA { typedef struct _X11DRV_MONITOR_DATA {
Screen *screen;
Window rootWindow;
int width; int width;
int height; int height;
int depth;
} X11DRV_MONITOR_DATA; } X11DRV_MONITOR_DATA;
struct tagMONITOR; struct tagMONITOR;
extern Screen *X11DRV_MONITOR_GetXScreen(struct tagMONITOR *pMonitor);
extern Window X11DRV_MONITOR_GetXRootWindow(struct tagMONITOR *pMonitor);
extern void X11DRV_MONITOR_Initialize(struct tagMONITOR *pMonitor); extern void X11DRV_MONITOR_Initialize(struct tagMONITOR *pMonitor);
extern void X11DRV_MONITOR_Finalize(struct tagMONITOR *pMonitor); extern void X11DRV_MONITOR_Finalize(struct tagMONITOR *pMonitor);
extern BOOL X11DRV_MONITOR_IsSingleWindow(struct tagMONITOR *pMonitor); extern BOOL X11DRV_MONITOR_IsSingleWindow(struct tagMONITOR *pMonitor);
@ -425,8 +419,6 @@ typedef struct _X11DRV_WND_DATA {
extern Window X11DRV_WND_GetXWindow(struct tagWND *wndPtr); extern Window X11DRV_WND_GetXWindow(struct tagWND *wndPtr);
extern Window X11DRV_WND_FindXWindow(struct tagWND *wndPtr); extern Window X11DRV_WND_FindXWindow(struct tagWND *wndPtr);
extern Screen *X11DRV_WND_GetXScreen(struct tagWND *wndPtr);
extern Window X11DRV_WND_GetXRootWindow(struct tagWND *wndPtr);
extern void X11DRV_WND_Initialize(struct tagWND *wndPtr); extern void X11DRV_WND_Initialize(struct tagWND *wndPtr);
extern void X11DRV_WND_Finalize(struct tagWND *wndPtr); extern void X11DRV_WND_Finalize(struct tagWND *wndPtr);

1
windows/ttydrv/Makefile.in
View File

@ -11,7 +11,6 @@ C_SRCS = \
event.c \ event.c \
init.c \ init.c \
keyboard.c \ keyboard.c \
main.c \
monitor.c \ monitor.c \
mouse.c \ mouse.c \
wnd.c wnd.c

18
windows/ttydrv/main.c
View File

@ -1,18 +0,0 @@
/*
* TTY main driver
*
* Copyright 1998 Patrik Stridvall
*
*/
#include "config.h"
#include "clipboard.h"
#include "desktop.h"
#include "message.h"
#include "keyboard.h"
#include "monitor.h"
#include "mouse.h"
#include "ttydrv.h"
#include "win.h"

2
windows/x11drv/Makefile.in
View File

@ -7,11 +7,9 @@ MODULE = x11drv
C_SRCS = \ C_SRCS = \
clipboard.c \ clipboard.c \
desktop.c \
event.c \ event.c \
init.c \ init.c \
keyboard.c \ keyboard.c \
main.c \
monitor.c \ monitor.c \
mouse.c \ mouse.c \
wnd.c wnd.c

40
windows/x11drv/desktop.c
View File

@ -1,40 +0,0 @@
/*
* X11 desktop driver
*
* Copyright 1998 Patrik Stridvall
*
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "debugtools.h"
#include "desktop.h"
#include "monitor.h"
#include "options.h"
#include "win.h"
#include "windef.h"
#include "x11drv.h"
/***********************************************************************
* X11DRV_DESKTOP_GetXScreen
*
* Return the X screen associated to the desktop.
*/
Screen *X11DRV_DESKTOP_GetXScreen(DESKTOP *pDesktop)
{
return X11DRV_MONITOR_GetXScreen(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* X11DRV_DESKTOP_GetXRootWindow
*
* Return the X root window associated to the desktop.
*/
Window X11DRV_DESKTOP_GetXRootWindow(DESKTOP *pDesktop)
{
return X11DRV_MONITOR_GetXRootWindow(pDesktop->pPrimaryMonitor);
}
#endif /* X_DISPLAY_MISSING */

56
windows/x11drv/main.c
View File

@ -1,56 +0,0 @@
/*
* X11 main driver
*
* Copyright 1998 Patrik Stridvall
*
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Xlocale.h>
#include "ts_xlib.h"
#include "ts_xresource.h"
#include "ts_xutil.h"
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "clipboard.h"
#include "debugtools.h"
#include "desktop.h"
#include "keyboard.h"
#include "main.h"
#include "message.h"
#include "monitor.h"
#include "mouse.h"
#include "options.h"
#include "win.h"
#include "windef.h"
#include "x11drv.h"
/***********************************************************************
* X11DRV_GetXScreen
*
* Return the X screen associated to the current desktop.
*/
Screen *X11DRV_GetXScreen()
{
return X11DRV_MONITOR_GetXScreen(&MONITOR_PrimaryMonitor);
}
/***********************************************************************
* X11DRV_GetXRootWindow
*
* Return the X display associated to the current desktop.
*/
Window X11DRV_GetXRootWindow()
{
return X11DRV_MONITOR_GetXRootWindow(&MONITOR_PrimaryMonitor);
}
#endif /* X_DISPLAY_MISSING */

80
windows/x11drv/monitor.c
View File

@ -21,36 +21,6 @@
#include "windef.h" #include "windef.h"
#include "x11drv.h" #include "x11drv.h"
/**********************************************************************/
extern Display *display;
/***********************************************************************
* X11DRV_MONITOR_GetXScreen
*
* Return the X screen associated to the MONITOR.
*/
Screen *X11DRV_MONITOR_GetXScreen(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor =
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return pX11Monitor->screen;
}
/***********************************************************************
* X11DRV_MONITOR_GetXRootWindow
*
* Return the X screen associated to the MONITOR.
*/
Window X11DRV_MONITOR_GetXRootWindow(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor =
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return pX11Monitor->rootWindow;
}
/*********************************************************************** /***********************************************************************
* X11DRV_MONITOR_CreateDesktop * X11DRV_MONITOR_CreateDesktop
* FIXME * FIXME
@ -87,8 +57,7 @@ static void X11DRV_MONITOR_CreateDesktop(MONITOR *pMonitor)
ButtonReleaseMask | EnterWindowMask; ButtonReleaseMask | EnterWindowMask;
win_attr.cursor = TSXCreateFontCursor( display, XC_top_left_arrow ); win_attr.cursor = TSXCreateFontCursor( display, XC_top_left_arrow );
pX11Monitor->rootWindow = root_window = TSXCreateWindow( display,
TSXCreateWindow( display,
DefaultRootWindow(display), DefaultRootWindow(display),
x, y, width, height, 0, x, y, width, height, 0,
CopyFromParent, InputOutput, CopyFromParent, CopyFromParent, InputOutput, CopyFromParent,
@ -118,17 +87,17 @@ static void X11DRV_MONITOR_CreateDesktop(MONITOR *pMonitor)
class_hints->res_class = "Wine"; class_hints->res_class = "Wine";
TSXStringListToTextProperty( &name, 1, &window_name ); TSXStringListToTextProperty( &name, 1, &window_name );
TSXSetWMProperties( display, pX11Monitor->rootWindow, &window_name, &window_name, TSXSetWMProperties( display, root_window, &window_name, &window_name,
Options.argv, Options.argc, size_hints, wm_hints, class_hints ); Options.argv, Options.argc, size_hints, wm_hints, class_hints );
XA_WM_DELETE_WINDOW = TSXInternAtom( display, "WM_DELETE_WINDOW", False ); XA_WM_DELETE_WINDOW = TSXInternAtom( display, "WM_DELETE_WINDOW", False );
TSXSetWMProtocols( display, pX11Monitor->rootWindow, &XA_WM_DELETE_WINDOW, 1 ); TSXSetWMProtocols( display, root_window, &XA_WM_DELETE_WINDOW, 1 );
TSXFree( size_hints ); TSXFree( size_hints );
TSXFree( wm_hints ); TSXFree( wm_hints );
TSXFree( class_hints ); TSXFree( class_hints );
/* Map window */ /* Map window */
TSXMapWindow( display, pX11Monitor->rootWindow ); TSXMapWindow( display, root_window );
} }
/*********************************************************************** /***********************************************************************
@ -139,37 +108,12 @@ void X11DRV_MONITOR_Initialize(MONITOR *pMonitor)
X11DRV_MONITOR_DATA *pX11Monitor = (X11DRV_MONITOR_DATA *) X11DRV_MONITOR_DATA *pX11Monitor = (X11DRV_MONITOR_DATA *)
HeapAlloc(SystemHeap, 0, sizeof(X11DRV_MONITOR_DATA)); HeapAlloc(SystemHeap, 0, sizeof(X11DRV_MONITOR_DATA));
int depth_count, i;
int *depth_list;
pMonitor->pDriverData = pX11Monitor; pMonitor->pDriverData = pX11Monitor;
pX11Monitor->screen = DefaultScreenOfDisplay( display ); pX11Monitor->width = WidthOfScreen( screen );
pX11Monitor->height = HeightOfScreen( screen );
pX11Monitor->width = WidthOfScreen( pX11Monitor->screen ); if (Options.desktopGeometry) X11DRV_MONITOR_CreateDesktop(pMonitor);
pX11Monitor->height = HeightOfScreen( pX11Monitor->screen );
pX11Monitor->depth = PROFILE_GetWineIniInt( "x11drv", "ScreenDepth", 0 );
if (pX11Monitor->depth) /* depth specified */
{
depth_list = TSXListDepths(display, DefaultScreen(display), &depth_count);
for (i = 0; i < depth_count; i++)
if (depth_list[i] == pX11Monitor->depth) break;
TSXFree( depth_list );
if (i >= depth_count)
{
MESSAGE( "%s: Depth %d not supported on this screen.\n", argv0, pX11Monitor->depth );
exit(1);
}
}
else
pX11Monitor->depth = DefaultDepthOfScreen( pX11Monitor->screen );
if (Options.desktopGeometry)
X11DRV_MONITOR_CreateDesktop(pMonitor);
else
pX11Monitor->rootWindow =
DefaultRootWindow( display );
} }
/*********************************************************************** /***********************************************************************
@ -185,10 +129,7 @@ void X11DRV_MONITOR_Finalize(MONITOR *pMonitor)
*/ */
BOOL X11DRV_MONITOR_IsSingleWindow(MONITOR *pMonitor) BOOL X11DRV_MONITOR_IsSingleWindow(MONITOR *pMonitor)
{ {
X11DRV_MONITOR_DATA *pX11Monitor = return (root_window != DefaultRootWindow(display));
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return (pX11Monitor->rootWindow != DefaultRootWindow(display));
} }
/*********************************************************************** /***********************************************************************
@ -224,10 +165,7 @@ int X11DRV_MONITOR_GetHeight(MONITOR *pMonitor)
*/ */
int X11DRV_MONITOR_GetDepth(MONITOR *pMonitor) int X11DRV_MONITOR_GetDepth(MONITOR *pMonitor)
{ {
X11DRV_MONITOR_DATA *pX11Monitor = return screen_depth;
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return pX11Monitor->depth;
} }
/*********************************************************************** /***********************************************************************

2
windows/x11drv/mouse.c
View File

@ -66,7 +66,7 @@ static BOOL X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
*/ */
pixmapAll = XCreatePixmap( display, X11DRV_GetXRootWindow(), pixmapAll = XCreatePixmap( display, X11DRV_GetXRootWindow(),
ptr->nWidth, ptr->nHeight * 2, 1 ); ptr->nWidth, ptr->nHeight * 2, 1 );
image = XCreateImage( display, DefaultVisualOfScreen(X11DRV_GetXScreen()), image = XCreateImage( display, X11DRV_GetVisual(),
1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth, 1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
ptr->nHeight * 2, 16, ptr->nWidthBytes); ptr->nHeight * 2, 16, ptr->nWidthBytes);
if (image) if (image)

42
windows/x11drv/wnd.c
View File

@ -81,28 +81,6 @@ Window X11DRV_WND_FindXWindow(WND *wndPtr)
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window : 0; ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window : 0;
} }
/***********************************************************************
* X11DRV_WND_GetXScreen
*
* Return the X screen associated to the window.
*/
Screen *X11DRV_WND_GetXScreen(WND *wndPtr)
{
while(wndPtr->parent) wndPtr = wndPtr->parent;
return X11DRV_DESKTOP_GetXScreen((struct tagDESKTOP *) wndPtr->wExtra);
}
/***********************************************************************
* X11DRV_WND_GetXRootWindow
*
* Return the X display associated to the window.
*/
Window X11DRV_WND_GetXRootWindow(WND *wndPtr)
{
while(wndPtr->parent) wndPtr = wndPtr->parent;
return X11DRV_DESKTOP_GetXRootWindow((struct tagDESKTOP *) wndPtr->wExtra);
}
/*********************************************************************** /***********************************************************************
* X11DRV_WND_RegisterWindow * X11DRV_WND_RegisterWindow
* *
@ -172,8 +150,7 @@ BOOL X11DRV_WND_CreateDesktopWindow(WND *wndPtr, CLASS *classPtr, BOOL bUnicode)
if (kwmDockWindow == None) if (kwmDockWindow == None)
kwmDockWindow = TSXInternAtom( display, "KWM_DOCKWINDOW", False ); kwmDockWindow = TSXInternAtom( display, "KWM_DOCKWINDOW", False );
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = X11DRV_GetXRootWindow();
X11DRV_WND_GetXRootWindow( wndPtr );
X11DRV_WND_RegisterWindow( wndPtr ); X11DRV_WND_RegisterWindow( wndPtr );
return TRUE; return TRUE;
@ -188,8 +165,7 @@ BOOL X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCTA *cs, BO
/* Create the X window (only for top-level windows, and then only */ /* Create the X window (only for top-level windows, and then only */
/* when there's no desktop window) */ /* when there's no desktop window) */
if (!(cs->style & WS_CHILD) && if (!(cs->style & WS_CHILD) && (X11DRV_GetXRootWindow() == DefaultRootWindow(display)))
(X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display)))
{ {
Window wGroupLeader; Window wGroupLeader;
XWMHints* wm_hints; XWMHints* wm_hints;
@ -222,8 +198,7 @@ BOOL X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCTA *cs, BO
((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap = 0; ((X11DRV_WND_DATA *) wndPtr->pDriverData)->hWMIconBitmap = 0;
((X11DRV_WND_DATA *) wndPtr->pDriverData)->bit_gravity = win_attr.bit_gravity; ((X11DRV_WND_DATA *) wndPtr->pDriverData)->bit_gravity = win_attr.bit_gravity;
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = ((X11DRV_WND_DATA *) wndPtr->pDriverData)->window =
TSXCreateWindow( display, TSXCreateWindow( display, X11DRV_GetXRootWindow(),
X11DRV_WND_GetXRootWindow(wndPtr),
cs->x, cs->y, cs->cx, cs->cy, cs->x, cs->y, cs->cx, cs->cy,
0, CopyFromParent, 0, CopyFromParent,
InputOutput, CopyFromParent, InputOutput, CopyFromParent,
@ -384,7 +359,7 @@ WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
{ {
wndPtr->dwStyle &= ~WS_CHILD; wndPtr->dwStyle &= ~WS_CHILD;
wndPtr->wIDmenu = 0; wndPtr->wIDmenu = 0;
if( X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display) ) if( X11DRV_GetXRootWindow() == DefaultRootWindow(display) )
{ {
CREATESTRUCTA cs; CREATESTRUCTA cs;
cs.lpCreateParams = NULL; cs.lpCreateParams = NULL;
@ -609,7 +584,7 @@ void X11DRV_WND_SetFocus(WND *wndPtr)
/* Only mess with the X focus if there's */ /* Only mess with the X focus if there's */
/* no desktop window and if the window is not managed by the WM. */ /* no desktop window and if the window is not managed by the WM. */
if ((X11DRV_WND_GetXRootWindow(wndPtr) != DefaultRootWindow(display)) if ((X11DRV_GetXRootWindow() != DefaultRootWindow(display))
|| (wndPtr->flags & WIN_MANAGED)) return; || (wndPtr->flags & WIN_MANAGED)) return;
if (!hwnd) /* If setting the focus to 0, uninstall the colormap */ if (!hwnd) /* If setting the focus to 0, uninstall the colormap */
@ -638,8 +613,7 @@ void X11DRV_WND_SetFocus(WND *wndPtr)
*/ */
void X11DRV_WND_PreSizeMove(WND *wndPtr) void X11DRV_WND_PreSizeMove(WND *wndPtr)
{ {
if (!(wndPtr->dwStyle & WS_CHILD) && if (!(wndPtr->dwStyle & WS_CHILD) && (X11DRV_GetXRootWindow() == DefaultRootWindow(display)))
(X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display)))
TSXGrabServer( display ); TSXGrabServer( display );
} }
@ -698,7 +672,7 @@ void X11DRV_WND_SetDrawable(WND *wndPtr, DC *dc, WORD flags, BOOL bSetClipOrigin
{ {
dc->w.DCOrgX = 0; dc->w.DCOrgX = 0;
dc->w.DCOrgY = 0; dc->w.DCOrgY = 0;
physDev->drawable = X11DRV_WND_GetXRootWindow(wndPtr); physDev->drawable = X11DRV_GetXRootWindow();
TSXSetSubwindowMode( display, physDev->gc, IncludeInferiors ); TSXSetSubwindowMode( display, physDev->gc, IncludeInferiors );
} }
else else
@ -832,7 +806,7 @@ BOOL X11DRV_WND_SetHostAttr(WND* wnd, INT ha, INT value)
ev.window = w; ev.window = w;
if( TSXSendEvent (display, if( TSXSendEvent (display,
RootWindow( display, XScreenNumberOfScreen(X11DRV_WND_GetXScreen(wnd)) ), RootWindow( display, XScreenNumberOfScreen(X11DRV_GetXScreen()) ),
True, (SubstructureRedirectMask | SubstructureNotifyMask), (XEvent*)&ev)) True, (SubstructureRedirectMask | SubstructureNotifyMask), (XEvent*)&ev))
{ {
XEvent xe; XEvent xe;