Skip to content

W
wine-cw
Commit ab121e78 authored by Patrik Stridvall's avatar Patrik Stridvall Committed by Alexandre Julliard
Browse files
Options

X11 driver changes.

parent 48b5de83
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 672 additions and 187 deletions
graphics/x11drv/bitblt.c
View file @ ab121e78
......@@ -4,8 +4,12 @@
* Copyright 1993, 1994 Alexandre Julliard
*/
#include "ts_xlib.h"
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Intrinsic.h>
#include "ts_xlib.h"
#include <assert.h>
#include <stdio.h>
......@@ -18,7 +22,7 @@
#include "options.h"
#include "x11drv.h"
#include "debug.h"
#include "xmalloc.h"
#include "xmalloc.h" /* for XCREATEIMAGE macro */
#define DST 0 /* Destination drawable */
......@@ -1203,8 +1207,8 @@ static BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
/* Xor is much better when we do not have full colormap. */
/* Using white^black ensures that we invert at least black */
/* and white. */
Pixel xor_pix = (WhitePixelOfScreen(screen) ^
BlackPixelOfScreen(screen));
Pixel xor_pix = (WhitePixelOfScreen(X11DRV_GetXScreen()) ^
BlackPixelOfScreen(X11DRV_GetXScreen()));
XSetFunction( display, physDevDst->gc, GXxor );
XSetForeground( display, physDevDst->gc, xor_pix);
XSetFillStyle( display, physDevDst->gc, FillSolid );
......@@ -1286,11 +1290,11 @@ static BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
}
tmpGC = XCreateGC( display, physDevDst->drawable, 0, NULL );
pixmaps[DST] = XCreatePixmap( display, rootWindow, width, height,
pixmaps[DST] = XCreatePixmap( display, X11DRV_GetXRootWindow(), width, height,
dcDst->w.bitsPerPixel );
if (useSrc)
{
pixmaps[SRC] = XCreatePixmap( display, rootWindow, width, height,
pixmaps[SRC] = XCreatePixmap( display, X11DRV_GetXRootWindow(), width, height,
dcDst->w.bitsPerPixel );
if (fStretch)
BITBLT_GetSrcAreaStretch( dcSrc, dcDst, pixmaps[SRC], tmpGC,
......@@ -1315,7 +1319,7 @@ static BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
case OP_ARGS(DST,TMP):
case OP_ARGS(SRC,TMP):
if (!pixmaps[TMP])
pixmaps[TMP] = XCreatePixmap( display, rootWindow,
pixmaps[TMP] = XCreatePixmap( display, X11DRV_GetXRootWindow(),
width, height,
dcDst->w.bitsPerPixel );
/* fall through */
......@@ -1330,7 +1334,7 @@ static BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
case OP_ARGS(PAT,TMP):
if (!pixmaps[TMP] && !fNullBrush)
pixmaps[TMP] = XCreatePixmap( display, rootWindow,
pixmaps[TMP] = XCreatePixmap( display, X11DRV_GetXRootWindow(),
width, height,
dcDst->w.bitsPerPixel );
/* fall through */
......@@ -1439,3 +1443,5 @@ BOOL32 X11DRV_StretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
DIB_UpdateDIBSection( dcDst, TRUE );
return result;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/bitmap.c
View file @ ab121e78
......@@ -4,18 +4,26 @@
* Copyright 1993 Alexandre Julliard
*/
#include <stdio.h>
#include <stdlib.h>
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "ts_xlib.h"
#include "ts_xutil.h"
#include <stdio.h>
#include <stdlib.h>
#include "gdi.h"
#include "callback.h"
#include "dc.h"
#include "bitmap.h"
#include "heap.h"
#include "monitor.h"
#include "debug.h"
#include "xmalloc.h"
#include "local.h"
#include "x11drv.h"
#include "wine/winuser16.h"
/* GCs used for B&W and color bitmap operations */
GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
......@@ -30,16 +38,22 @@ BOOL32 X11DRV_BITMAP_Init(void)
/* Create the necessary GCs */
if ((tmpPixmap = TSXCreatePixmap( display, rootWindow, 1, 1, 1 )))
if ((tmpPixmap = TSXCreatePixmap(display,
X11DRV_GetXRootWindow(),
1, 1,
1)))
{
BITMAP_monoGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
TSXSetGraphicsExposures( display, BITMAP_monoGC, False );
TSXFreePixmap( display, tmpPixmap );
}
if (screenDepth != 1)
if (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) != 1)
{
if ((tmpPixmap = TSXCreatePixmap(display, rootWindow, 1,1,screenDepth)))
if ((tmpPixmap = TSXCreatePixmap(display,
X11DRV_GetXRootWindow(),
1, 1,
MONITOR_GetDepth(&MONITOR_PrimaryMonitor))))
{
BITMAP_colorGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
TSXSetGraphicsExposures( display, BITMAP_colorGC, False );
......@@ -180,7 +194,7 @@ BOOL32 X11DRV_CreateBitmap( HBITMAP32 hbitmap )
/* Check parameters */
if (bmp->bitmap.bmPlanes != 1) return 0;
if ((bmp->bitmap.bmBitsPixel != 1) &&
(bmp->bitmap.bmBitsPixel != screenDepth)) {
(bmp->bitmap.bmBitsPixel != MONITOR_GetDepth(&MONITOR_PrimaryMonitor))) {
ERR(x11drv, "Trying to make bitmap with planes=%d, bpp=%d\n",
bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel);
GDI_HEAP_UNLOCK( hbitmap );
......@@ -194,7 +208,7 @@ BOOL32 X11DRV_CreateBitmap( HBITMAP32 hbitmap )
if(!pbitmap) return FALSE;
/* Create the pixmap */
pbitmap->pixmap = TSXCreatePixmap(display, rootWindow, bmp->bitmap.bmWidth,
pbitmap->pixmap = TSXCreatePixmap(display, X11DRV_GetXRootWindow(), bmp->bitmap.bmWidth,
bmp->bitmap.bmHeight, bmp->bitmap.bmBitsPixel);
if (!pbitmap->pixmap) {
WARN(x11drv, "Can't create Pixmap\n");
......@@ -380,7 +394,7 @@ static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
height = count / bmp->bitmap.bmWidthBytes;
EnterCriticalSection( &X11DRV_CritSection );
image = XCreateImage( display, DefaultVisualOfScreen(screen),
image = XCreateImage( display, DefaultVisualOfScreen(X11DRV_GetXScreen()),
bmp->bitmap.bmBitsPixel, ZPixmap, 0, NULL,
bmp->bitmap.bmWidth, height, 32, 0 );
image->data = (LPBYTE)xmalloc(image->bytes_per_line * height);
......@@ -510,3 +524,5 @@ BOOL32 X11DRV_BITMAP_DeleteObject( HBITMAP32 hbitmap, BITMAPOBJ * bmp )
return TRUE;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/brush.c
View file @ ab121e78
......@@ -4,6 +4,10 @@
* Copyright 1993, 1994 Alexandre Julliard
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "ts_xlib.h"
#include <stdlib.h>
......@@ -12,6 +16,9 @@
#include "color.h"
#include "x11drv.h"
#include "debug.h"
#include "xmalloc.h" /* for XCREATEIMAGE macro */
#include "monitor.h"
#include "local.h"
static const char HatchBrushes[NB_HATCH_STYLES + 1][8] =
{
......@@ -94,7 +101,7 @@ static XImage *ditherImage = NULL;
*/
BOOL32 X11DRV_BRUSH_Init(void)
{
XCREATEIMAGE( ditherImage, MATRIX_SIZE, MATRIX_SIZE, screenDepth );
XCREATEIMAGE( ditherImage, MATRIX_SIZE, MATRIX_SIZE, MONITOR_GetDepth(&MONITOR_PrimaryMonitor) );
return (ditherImage != NULL);
}
......@@ -130,8 +137,8 @@ static Pixmap BRUSH_DitherColor( DC *dc, COLORREF color )
prevColor = color;
}
pixmap = XCreatePixmap( display, rootWindow,
MATRIX_SIZE, MATRIX_SIZE, screenDepth );
pixmap = XCreatePixmap( display, X11DRV_GetXRootWindow(),
MATRIX_SIZE, MATRIX_SIZE, MONITOR_GetDepth(&MONITOR_PrimaryMonitor) );
XPutImage( display, pixmap, BITMAP_colorGC, ditherImage, 0, 0,
0, 0, MATRIX_SIZE, MATRIX_SIZE );
LeaveCriticalSection( &X11DRV_CritSection );
......@@ -146,7 +153,7 @@ static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color )
{
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
if ((dc->w.bitsPerPixel > 1) && (screenDepth <= 8) && !COLOR_IsSolid( color ))
if ((dc->w.bitsPerPixel > 1) && (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8) && !COLOR_IsSolid( color ))
{
/* Dithered brush */
physDev->brush.pixmap = BRUSH_DitherColor( dc, color );
......@@ -186,14 +193,14 @@ static BOOL32 BRUSH_SelectPatternBrush( DC * dc, HBITMAP32 hbitmap )
if ((dc->w.bitsPerPixel == 1) && (bmp->bitmap.bmBitsPixel != 1))
{
/* Special case: a color pattern on a monochrome DC */
physDev->brush.pixmap = TSXCreatePixmap( display, rootWindow, 8, 8, 1);
physDev->brush.pixmap = TSXCreatePixmap( display, X11DRV_GetXRootWindow(), 8, 8, 1);
/* FIXME: should probably convert to monochrome instead */
TSXCopyPlane( display, pbitmap->pixmap, physDev->brush.pixmap,
BITMAP_monoGC, 0, 0, 8, 8, 0, 0, 1 );
}
else
{
physDev->brush.pixmap = TSXCreatePixmap( display, rootWindow,
physDev->brush.pixmap = TSXCreatePixmap( display, X11DRV_GetXRootWindow(),
8, 8, bmp->bitmap.bmBitsPixel );
TSXCopyArea( display, pbitmap->pixmap, physDev->brush.pixmap,
BITMAP_GC(bmp), 0, 0, 8, 8, 0, 0 );
......@@ -252,7 +259,7 @@ HBRUSH32 X11DRV_BRUSH_SelectObject( DC * dc, HBRUSH32 hbrush, BRUSHOBJ * brush )
case BS_HATCHED:
TRACE(gdi, "BS_HATCHED\n" );
physDev->brush.pixel = COLOR_ToPhysical( dc, brush->logbrush.lbColor );
physDev->brush.pixmap = TSXCreateBitmapFromData( display, rootWindow,
physDev->brush.pixmap = TSXCreateBitmapFromData( display, X11DRV_GetXRootWindow(),
HatchBrushes[brush->logbrush.lbHatch], 8, 8 );
physDev->brush.fillStyle = FillStippled;
break;
......@@ -281,3 +288,6 @@ HBRUSH32 X11DRV_BRUSH_SelectObject( DC * dc, HBRUSH32 hbrush, BRUSHOBJ * brush )
return prevHandle;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/clipping.c
View file @ ab121e78
......@@ -4,6 +4,10 @@
* Copyright 1998 Huw Davies
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "ts_xlib.h"
#include <stdio.h>
......@@ -12,6 +16,7 @@
#include "region.h"
#include "debug.h"
#include "heap.h"
#include "local.h"
/***********************************************************************
* X11DRV_SetDeviceClipping
......@@ -65,3 +70,6 @@ void X11DRV_SetDeviceClipping( DC * dc )
GDI_HEAP_UNLOCK( dc->w.hGCClipRgn );
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/dib.c
View file @ ab121e78
......@@ -4,15 +4,21 @@
* Copyright 1993,1994 Alexandre Julliard
*/
#include "windows.h"
#include "bitmap.h"
#include "x11drv.h"
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "ts_xlib.h"
#include "ts_xutil.h"
#include "wintypes.h"
#include "bitmap.h"
#include "x11drv.h"
#include "debug.h"
#include "dc.h"
#include "color.h"
#include "callback.h"
#include "xmalloc.h" /* for XCREATEIMAGE macro */
static int bitmapDepthTable[] = { 8, 1, 32, 16, 24, 15, 4, 0 };
static int ximageDepthTable[] = { 0, 0, 0, 0, 0, 0, 0 };
......@@ -27,7 +33,7 @@ BOOL32 X11DRV_DIB_Init(void)
for( i = 0; bitmapDepthTable[i]; i++ )
{
testimage = TSXCreateImage(display, DefaultVisualOfScreen(screen),
testimage = TSXCreateImage(display, DefaultVisualOfScreen(X11DRV_GetXScreen()),
bitmapDepthTable[i], ZPixmap, 0, NULL, 1, 1, 32, 20 );
if( testimage ) ximageDepthTable[i] = testimage->bits_per_pixel;
else return FALSE;
......@@ -1151,3 +1157,5 @@ INT32 X11DRV_SetDIBitsToDevice( DC *dc, INT32 xDest, INT32 yDest, DWORD cx,
HeapFree(GetProcessHeap(), 0, descr.colorMap);
return result;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/graphics.c
View file @ ab121e78
......@@ -4,20 +4,24 @@
* Copyright 1993,1994 Alexandre Julliard
*/
/*
* FIXME: none of these functions obey the GM_ADVANCED
* graphics mode
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Intrinsic.h>
#include "ts_xlib.h"
#include "ts_xutil.h"
#include <math.h>
#ifdef HAVE_FLOAT_H
# include <float.h>
#endif
#include <stdlib.h>
#include "ts_xlib.h"
#include "ts_xutil.h"
#include <X11/Intrinsic.h>
#ifndef PI
#define PI M_PI
#endif
......@@ -28,6 +32,7 @@
#include "bitmap.h"
#include "gdi.h"
#include "dc.h"
#include "monitor.h"
#include "bitmap.h"
#include "callback.h"
#include "metafile.h"
......@@ -107,7 +112,7 @@ BOOL32 X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL32 fMapColors )
*/
if (val.function == GXinvert)
{
val.foreground = BlackPixelOfScreen(screen) ^ WhitePixelOfScreen(screen);
val.foreground = BlackPixelOfScreen(X11DRV_GetXScreen()) ^ WhitePixelOfScreen(X11DRV_GetXScreen());
val.function = GXxor;
}
val.fill_style = physDev->brush.fillStyle;
......@@ -126,7 +131,10 @@ BOOL32 X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL32 fMapColors )
register int x, y;
XImage *image;
EnterCriticalSection( &X11DRV_CritSection );
pixmap = XCreatePixmap( display, rootWindow, 8, 8, screenDepth );
pixmap = XCreatePixmap( display,
X11DRV_GetXRootWindow(),
8, 8,
MONITOR_GetDepth(&MONITOR_PrimaryMonitor) );
image = XGetImage( display, physDev->brush.pixmap, 0, 0, 8, 8,
AllPlanes, ZPixmap );
for (y = 0; y < 8; y++)
......@@ -189,11 +197,11 @@ BOOL32 X11DRV_SetupGCForPen( DC * dc )
switch (dc->w.ROPmode)
{
case R2_BLACK :
val.foreground = BlackPixelOfScreen( screen );
val.foreground = BlackPixelOfScreen( X11DRV_GetXScreen() );
val.function = GXcopy;
break;
case R2_WHITE :
val.foreground = WhitePixelOfScreen( screen );
val.foreground = WhitePixelOfScreen( X11DRV_GetXScreen() );
val.function = GXcopy;
break;
case R2_XORPEN :
......@@ -201,8 +209,8 @@ BOOL32 X11DRV_SetupGCForPen( DC * dc )
/* It is very unlikely someone wants to XOR with 0 */
/* This fixes the rubber-drawings in paintbrush */
if (val.foreground == 0)
val.foreground = BlackPixelOfScreen( screen )
^ WhitePixelOfScreen( screen );
val.foreground = BlackPixelOfScreen( X11DRV_GetXScreen() )
^ WhitePixelOfScreen( X11DRV_GetXScreen() );
val.function = GXxor;
break;
default :
......@@ -854,7 +862,7 @@ X11DRV_GetPixel( DC *dc, INT32 x, INT32 y )
{
/* If we are reading from the screen, use a temporary copy */
/* to avoid a BadMatch error */
if (!pixmap) pixmap = XCreatePixmap( display, rootWindow,
if (!pixmap) pixmap = XCreatePixmap( display, X11DRV_GetXRootWindow(),
1, 1, dc->w.bitsPerPixel );
XCopyArea( display, physDev->drawable, pixmap, BITMAP_colorGC,
x, y, 1, 1, 0, 0 );
......@@ -1427,3 +1435,5 @@ X11DRV_SetTextColor( DC *dc, COLORREF color )
return oldColor;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/init.c
View file @ ab121e78
......@@ -4,6 +4,10 @@
* Copyright 1996 Alexandre Julliard
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "ts_xlib.h"
#include <string.h>
......@@ -11,7 +15,10 @@
#include "color.h"
#include "bitmap.h"
#include "winnt.h"
#include "local.h"
#include "debug.h"
#include "ldt.h"
#include "monitor.h"
static BOOL32 X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
LPCSTR output, const DEVMODE16* initData );
......@@ -129,16 +136,16 @@ BOOL32 X11DRV_Init(void)
#if 0
TRACE(x11drv, "Height = %-4i pxl, %-4i mm, Width = %-4i pxl, %-4i mm\n",
HeightOfScreen(screen), HeightMMOfScreen(screen),
WidthOfScreen(screen), WidthMMOfScreen(screen) );
HeightOfScreen(X11DRV_GetXScreen()), HeightMMOfScreen(X11DRV_GetXScreen()),
WidthOfScreen(X11DRV_GetXScreen()), WidthMMOfScreen(X11DRV_GetXScreen()) );
#endif
X11DRV_DevCaps.version = 0x300;
X11DRV_DevCaps.horzSize = WidthMMOfScreen(screen) * screenWidth / WidthOfScreen(screen);
X11DRV_DevCaps.vertSize = HeightMMOfScreen(screen) * screenHeight / HeightOfScreen(screen);
X11DRV_DevCaps.horzRes = screenWidth;
X11DRV_DevCaps.vertRes = screenHeight;
X11DRV_DevCaps.bitsPixel = screenDepth;
X11DRV_DevCaps.horzSize = WidthMMOfScreen(X11DRV_GetXScreen()) * MONITOR_GetWidth(&MONITOR_PrimaryMonitor) / WidthOfScreen(X11DRV_GetXScreen());
X11DRV_DevCaps.vertSize = HeightMMOfScreen(X11DRV_GetXScreen()) * MONITOR_GetHeight(&MONITOR_PrimaryMonitor) / HeightOfScreen(X11DRV_GetXScreen());
X11DRV_DevCaps.horzRes = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
X11DRV_DevCaps.vertRes = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
X11DRV_DevCaps.bitsPixel = MONITOR_GetDepth(&MONITOR_PrimaryMonitor);
if( COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL )
X11DRV_DevCaps.sizePalette = 0;
......@@ -205,14 +212,14 @@ static BOOL32 X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
}
else
{
physDev->drawable = rootWindow;
physDev->drawable = X11DRV_GetXRootWindow();
physDev->gc = TSXCreateGC( display, physDev->drawable, 0, NULL );
dc->w.bitsPerPixel = screenDepth;
dc->w.bitsPerPixel = MONITOR_GetDepth(&MONITOR_PrimaryMonitor);
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = screenWidth;
dc->w.totalExtent.bottom = screenHeight;
dc->w.totalExtent.right = MONITOR_GetWidth(&MONITOR_PrimaryMonitor);
dc->w.totalExtent.bottom = MONITOR_GetHeight(&MONITOR_PrimaryMonitor);
dc->w.hVisRgn = CreateRectRgnIndirect32( &dc->w.totalExtent );
}
......@@ -261,3 +268,4 @@ static INT32 X11DRV_Escape( DC *dc, INT32 nEscape, INT32 cbInput,
return 0;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/objects.c
View file @ ab121e78
......@@ -4,12 +4,17 @@
* Copyright 1993 Alexandre Julliard
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <stdlib.h>
#include <stdio.h>
#include "bitmap.h"
#include "brush.h"
#include "font.h"
#include "pen.h"
#include "local.h"
#include "debug.h"
......@@ -80,3 +85,5 @@ BOOL32 X11DRV_DeleteObject( HGDIOBJ32 handle )
GDI_HEAP_UNLOCK( handle );
return ret;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/oembitmap.c
View file @ ab121e78
......@@ -5,20 +5,33 @@
*
*/
#include <stdlib.h>
#include <string.h>
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "ts_xlib.h"
#include "ts_xutil.h"
#ifdef HAVE_LIBXXPM
#include "ts_xpm.h"
#include "gdi.h"
#include "x11drv.h"
#else /* defined(HAVE_LIBXXPM) */
typedef unsigned long Pixel;
#endif /* defined(HAVE_LIBXXPM) */
#include <stdlib.h>
#include <string.h>
#include "bitmap.h"
#include "callback.h"
#include "color.h"
#include "cursoricon.h"
#include "debug.h"
#include "gdi.h"
#include "heap.h"
#include "local.h"
#include "monitor.h"
#include "tweak.h"
#include "debug.h"
#include "x11drv.h"
/* Include OEM pixmaps */
#include "bitmaps/obm_cdrom"
......@@ -234,14 +247,17 @@ static HGLOBAL16 OBM_Cursors[NB_CURSORS];
/* palette indexes, but system colors that will be converted to */
/* indexes later on. */
#if 0
static const struct
#ifdef HAVE_LIBXXPM
static XpmColorSymbol
#else /* defined(HAVE_LIBXXPM) */
static struct
{
char * name;
COLORREF color;
} OBM_SymbolicColors[] =
#endif
static XpmColorSymbol OBM_Colors[] =
char *name;
char *value;
Pixel pixel;
}
#endif /* defined(HAVE_LIBXXPM) */
OBM_Colors[] =
{
{ "black", NULL, (Pixel)RGB(0,0,0) },
{ "white", NULL, (Pixel)RGB(255,255,255) },
......@@ -269,11 +285,14 @@ static XpmColorSymbol OBM_Colors[] =
/* This is needed to make sure that black is always 0 and */
/* white always 1, as required by Windows. */
#ifdef HAVE_LIBXXPM
static XpmColorSymbol OBM_BlackAndWhite[2] =
{
{ "black", NULL, 0 },
{ "white", NULL, 0xffffffff }
};
#endif /* defined(HAVE_LIBXXPM) */
/* This structure holds the arguments for OBM_CreateBitmaps() */
typedef struct
......@@ -315,6 +334,7 @@ static BOOL32 OBM_InitColorSymbols()
*
* Allocate a GDI bitmap.
*/
#ifdef HAVE_LIBXXPM
static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
WORD bpp, Pixmap pixmap )
{
......@@ -346,7 +366,7 @@ static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
GDI_HEAP_UNLOCK( hbitmap );
return hbitmap;
}
#endif /* defined(HAVE_LIBXXPM) */
/***********************************************************************
* OBM_CreateBitmaps
......@@ -357,6 +377,7 @@ static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
*/
static BOOL32 OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr )
{
#ifdef HAVE_LIBXXPM
Pixmap pixmap, pixmask;
XpmAttributes *attrs;
int err;
......@@ -364,12 +385,12 @@ static BOOL32 OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr )
attrs = (XpmAttributes *)HEAP_xalloc( GetProcessHeap(), 0,
XpmAttributesSize() );
attrs->valuemask = XpmColormap | XpmDepth | XpmColorSymbols |XpmHotspot;
attrs->colormap = COLOR_GetColormap();
attrs->depth = descr->color ? screenDepth : 1;
attrs->colormap = X11DRV_COLOR_GetColormap();
attrs->depth = descr->color ? MONITOR_GetDepth(&MONITOR_PrimaryMonitor) : 1;
attrs->colorsymbols = (attrs->depth > 1) ? OBM_Colors : OBM_BlackAndWhite;
attrs->numsymbols = (attrs->depth > 1) ? NB_COLOR_SYMBOLS : 2;
err = XpmCreatePixmapFromData( display, rootWindow, descr->data,
err = XpmCreatePixmapFromData( display, X11DRV_GetXRootWindow(), descr->data,
&pixmap, &pixmask, attrs );
if (err != XpmSuccess)
......@@ -394,6 +415,13 @@ static BOOL32 OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr )
return FALSE;
}
else return TRUE;
#else /* defined(HAVE_LIBXXPM) */
FIXME(x11drv,
"Xpm support not in the binary, "
"please install Xpm and recompile\n"
);
return FALSE;
#endif /* defined(HAVE_LIBXXPM) */
}
......@@ -595,3 +623,5 @@ BOOL32 X11DRV_OBM_Init(void)
return 1;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/pen.c
View file @ ab121e78
......@@ -4,8 +4,13 @@
* Copyright 1993 Alexandre Julliard
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "pen.h"
#include "color.h"
#include "x11drv.h"
#include "debug.h"
static const char PEN_dash[] = { 5,3 }; /* ----- ----- ----- */
......@@ -63,3 +68,5 @@ HPEN32 X11DRV_PEN_SelectObject( DC * dc, HPEN32 hpen, PENOBJ * pen )
return prevHandle;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/text.c
View file @ ab121e78
......@@ -4,17 +4,20 @@
* Copyright 1993,1994 Alexandre Julliard
*/
#include <stdlib.h>
#include "ts_xlib.h"
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Xatom.h>
#include "windows.h"
#include "ts_xlib.h"
#include <stdlib.h>
#include "wintypes.h"
#include <math.h>
#include "dc.h"
#include "gdi.h"
/*#include "callback.h"*/
#include "heap.h"
#include "x11font.h"
#include "debugstr.h"
#include "debug.h"
#define SWAP_INT(a,b) { int t = a; a = b; b = t; }
......@@ -347,3 +350,4 @@ X11DRV_ExtTextOut( DC *dc, INT32 x, INT32 y, UINT32 flags,
return TRUE;
}
#endif /* !defined(X_DISPLAY_MISSING) */
graphics/x11drv/xfont.c
View file @ ab121e78
......@@ -7,6 +7,14 @@
* have to be changed for that), dynamic font loading (FreeType).
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/Xatom.h>
#include "ts_xlib.h"
#include "x11font.h"
#endif /* !defined(X_DISPLAY_MISSING) */
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
......@@ -16,15 +24,15 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "ts_xlib.h"
#include <X11/Xatom.h>
#include <math.h>
#include <assert.h>
#include "heap.h"
#include "options.h"
#include "x11font.h"
#include "font.h"
#include "debug.h"
#include "ldt.h"
#ifndef X_DISPLAY_MISSING
#define X_PFONT_MAGIC (0xFADE0000)
#define X_FMC_MAGIC (0x0000CAFE)
......@@ -2687,6 +2695,8 @@ BOOL32 X11DRV_GetCharWidth( DC *dc, UINT32 firstChar, UINT32 lastChar,
return FALSE;
}
#endif /* !defined(X_DISPLAY_MISSING) */
/***********************************************************************
* *
* Font Resource API *
......@@ -2780,4 +2790,3 @@ BOOL32 WINAPI RemoveFontResource32W( LPCWSTR str )
return TRUE;
}
windows/x11drv/Makefile.in
View file @ ab121e78
......@@ -7,9 +7,12 @@ MODULE = x11drv
C_SRCS = \
clipboard.c \
desktop.c \
event.c \
init.c \
keyboard.c \
main.c \
monitor.c \
mouse.c \
wnd.c
......
windows/x11drv/clipboard.c
View file @ ab121e78
......@@ -12,13 +12,11 @@
#include <X11/Xatom.h>
#include "ts_xlib.h"
#include "windows.h"
#include "wintypes.h"
#include "clipboard.h"
#include "debug.h"
#include "message.h"
#include "win.h"
#include "wintypes.h"
#include "x11drv.h"
extern HWND32 hWndClipOwner;
......
windows/x11drv/desktop.c 0 → 100644
View file @ ab121e78
/*
* X11 desktop driver
*
* Copyright 1998 Patrik Stridvall
*
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include "debug.h"
#include "desktop.h"
#include "monitor.h"
#include "options.h"
#include "win.h"
#include "wintypes.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);
}
/***********************************************************************
* X11DRV_DESKTOP_Initialize
*/
void X11DRV_DESKTOP_Initialize(DESKTOP *pDesktop)
{
pDesktop->pPrimaryMonitor = &MONITOR_PrimaryMonitor;
}
/***********************************************************************
* X11DRV_DESKTOP_Finalize
*/
void X11DRV_DESKTOP_Finalize(DESKTOP *pDesktop)
{
}
/***********************************************************************
* X11DRV_DESKTOP_GetScreenWidth
*
* Return the width of the screen associated to the desktop.
*/
int X11DRV_DESKTOP_GetScreenWidth(DESKTOP *pDesktop)
{
return MONITOR_GetWidth(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* X11DRV_DESKTOP_GetScreenHeight
*
* Return the width of the screen associated to the desktop.
*/
int X11DRV_DESKTOP_GetScreenHeight(DESKTOP *pDesktop)
{
return MONITOR_GetHeight(pDesktop->pPrimaryMonitor);
}
/***********************************************************************
* X11DRV_DESKTOP_GetScreenDepth
*
* Return the depth of the screen associated to the desktop.
*/
int X11DRV_DESKTOP_GetScreenDepth(DESKTOP *pDesktop)
{
return MONITOR_GetDepth(pDesktop->pPrimaryMonitor);
}
#endif /* X_DISPLAY_MISSING */
windows/x11drv/event.c
View file @ ab121e78
......@@ -15,34 +15,26 @@
#include "ts_xutil.h"
#include <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <errno.h>
#include "windows.h"
#include "winnt.h"
#include "gdi.h"
#include "heap.h"
#include "queue.h"
#include "callback.h"
#include "class.h"
#include "clipboard.h"
#include "dce.h"
#include "module.h"
#include "options.h"
#include "winpos.h"
#include "dde_proc.h"
#include "debug.h"
#include "drive.h"
#include "shell.h"
#include "callback.h"
#include "heap.h"
#include "keyboard.h"
#include "message.h"
#include "mouse.h"
#include "debug.h"
#include "dde_proc.h"
#include "options.h"
#include "queue.h"
#include "shell.h"
#include "winpos.h"
#include "winsock.h"
#include "mouse.h"
#include "wintypes.h"
#include "x11drv.h"
/* X context to associate a hwnd to an X window */
extern XContext winContext;
......@@ -51,6 +43,9 @@ extern Atom wmDeleteWindow;
extern Atom dndProtocol;
extern Atom dndSelection;
extern void X11DRV_KEYBOARD_UpdateState(void);
extern void X11DRV_KEYBOARD_HandleEvent(WND *pWnd, XKeyEvent *event);
#define NB_BUTTONS 3 /* Windows can handle 3 buttons */
#define DndNotDnd -1 /* OffiX drag&drop */
......@@ -339,7 +334,7 @@ static void EVENT_ProcessEvent( XEvent *event )
Window root, child;
int root_x, root_y, child_x, child_y;
unsigned u;
TSXQueryPointer( display, rootWindow, &root, &child,
TSXQueryPointer( display, X11DRV_GetXRootWindow(), &root, &child,
&root_x, &root_y, &child_x, &child_y, &u);
if (TSXFindContext( display, child, winContext, (char **)&pWnd ) != 0)
return;
......@@ -585,7 +580,7 @@ BOOL32 X11DRV_EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state)
int rootX, rootY, winX, winY;
unsigned int xstate;
if (!TSXQueryPointer( display, rootWindow, &root, &child,
if (!TSXQueryPointer( display, X11DRV_GetXRootWindow(), &root, &child,
&rootX, &rootY, &winX, &winY, &xstate ))
return FALSE;
......@@ -647,7 +642,7 @@ static void EVENT_GraphicsExpose( WND *pWnd, XGraphicsExposeEvent *event )
*/
static void EVENT_Key( WND *pWnd, XKeyEvent *event )
{
KEYBOARD_HandleEvent( pWnd, event );
X11DRV_KEYBOARD_HandleEvent( pWnd, event );
}
......@@ -788,7 +783,7 @@ static void EVENT_FocusIn( WND *pWnd, XFocusChangeEvent *event )
if (hwnd != GetActiveWindow32())
{
WINPOS_ChangeActiveWindow( hwnd, FALSE );
KEYBOARD_UpdateState();
X11DRV_KEYBOARD_UpdateState();
}
if ((hwnd != GetFocus32()) && !IsChild32( hwnd, GetFocus32()))
SetFocus32( hwnd );
......@@ -845,7 +840,7 @@ static void EVENT_GetGeometry( Window win, int *px, int *py,
if (!TSXGetGeometry( display, win, &root, px, py, pwidth, pheight,
&border, &depth )) return;
if (win == rootWindow)
if (win == X11DRV_GetXRootWindow())
{
*px = *py = 0;
return;
......@@ -856,7 +851,7 @@ static void EVENT_GetGeometry( Window win, int *px, int *py,
if (!TSXQueryTree(display, win, &root, &parent, &children, &nb_children))
return;
TSXFree( children );
if (parent == rootWindow) break;
if (parent == X11DRV_GetXRootWindow()) break;
win = parent;
if (!TSXGetGeometry( display, win, &root, &xpos, &ypos,
&width, &height, &border, &depth )) return;
......@@ -1209,7 +1204,7 @@ static void EVENT_DropURLs( WND *pWnd, XClientMessageEvent *event )
}
if( drop_len && drop_len < 65535 ) {
TSXQueryPointer( display, rootWindow, &u.w_aux, &u.w_aux,
TSXQueryPointer( display, X11DRV_GetXRootWindow(), &u.w_aux, &u.w_aux,
&x, &y, &u.i, &u.i, &u.i);
pDropWnd = WIN_FindWndPtr( pWnd->hwndSelf );
......@@ -1342,9 +1337,9 @@ static void EVENT_ClientMessage( WND *pWnd, XClientMessageEvent *event )
#if 0
void EVENT_EnterNotify( WND *pWnd, XCrossingEvent *event )
{
if( !Options.managed && rootWindow == DefaultRootWindow(display) &&
if( !Options.managed && X11DRV_GetXRootWindow() == DefaultRootWindow(display) &&
(COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE) && GetFocus32() )
TSXInstallColormap( display, COLOR_GetColormap() );
TSXInstallColormap( display, X11DRV_COLOR_GetColormap() );
}
#endif
......@@ -1370,6 +1365,3 @@ BOOL32 X11DRV_EVENT_Pending()
}
#endif /* !defined(X_DISPLAY_MISSING) */
windows/x11drv/init.c
View file @ ab121e78
......@@ -8,27 +8,15 @@
#ifndef X_DISPLAY_MISSING
#include "clipboard.h"
#include "desktop.h"
#include "display.h"
#include "keyboard.h"
#include "message.h"
#include "monitor.h"
#include "win.h"
#include "x11drv.h"
WND_DRIVER X11DRV_WND_Driver =
{
X11DRV_WND_Initialize,
X11DRV_WND_Finalize,
X11DRV_WND_CreateDesktopWindow,
X11DRV_WND_CreateWindow,
X11DRV_WND_DestroyWindow,
X11DRV_WND_SetParent,
X11DRV_WND_ForceWindowRaise,
X11DRV_WND_SetWindowPos,
X11DRV_WND_SetText,
X11DRV_WND_SetFocus,
X11DRV_WND_PreSizeMove,
X11DRV_WND_PostSizeMove,
X11DRV_WND_ScrollWindow,
X11DRV_WND_SetDrawable,
X11DRV_WND_IsSelfClipping
};
CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
{
X11DRV_CLIPBOARD_EmptyClipboard,
......@@ -37,13 +25,10 @@ CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver =
X11DRV_CLIPBOARD_ResetOwner
};
KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver =
DESKTOP_DRIVER X11DRV_DESKTOP_Driver =
{
X11DRV_KEYBOARD_Init,
X11DRV_KEYBOARD_VkKeyScan,
X11DRV_KEYBOARD_MapVirtualKey,
X11DRV_KEYBOARD_GetKeyNameText,
X11DRV_KEYBOARD_ToAscii
X11DRV_DESKTOP_Initialize,
X11DRV_DESKTOP_Finalize
};
EVENT_DRIVER X11DRV_EVENT_Driver =
......@@ -60,12 +45,49 @@ EVENT_DRIVER X11DRV_EVENT_Driver =
X11DRV_EVENT_IsUserIdle
};
KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver =
{
X11DRV_KEYBOARD_Init,
X11DRV_KEYBOARD_VkKeyScan,
X11DRV_KEYBOARD_MapVirtualKey,
X11DRV_KEYBOARD_GetKeyNameText,
X11DRV_KEYBOARD_ToAscii
};
MONITOR_DRIVER X11DRV_MONITOR_Driver =
{
X11DRV_MONITOR_Initialize,
X11DRV_MONITOR_Finalize,
X11DRV_MONITOR_GetWidth,
X11DRV_MONITOR_GetHeight,
X11DRV_MONITOR_GetDepth
};
MOUSE_DRIVER X11DRV_MOUSE_Driver =
{
X11DRV_MOUSE_SetCursor,
X11DRV_MOUSE_MoveCursor
};
WND_DRIVER X11DRV_WND_Driver =
{
X11DRV_WND_Initialize,
X11DRV_WND_Finalize,
X11DRV_WND_CreateDesktopWindow,
X11DRV_WND_CreateWindow,
X11DRV_WND_DestroyWindow,
X11DRV_WND_SetParent,
X11DRV_WND_ForceWindowRaise,
X11DRV_WND_SetWindowPos,
X11DRV_WND_SetText,
X11DRV_WND_SetFocus,
X11DRV_WND_PreSizeMove,
X11DRV_WND_PostSizeMove,
X11DRV_WND_ScrollWindow,
X11DRV_WND_SetDrawable,
X11DRV_WND_IsSelfClipping
};
#endif /* !defined(X_DISPLAY_MISSING) */
windows/x11drv/keyboard.c
View file @ ab121e78
......@@ -19,6 +19,7 @@
#include "ts_xutil.h"
#include "debug.h"
#include "keyboard.h"
#include "message.h"
#include "wintypes.h"
#include "x11drv.h"
......@@ -168,7 +169,7 @@ void KEYBOARD_UpdateOneState ( int vkey, int state )
}
/***********************************************************************
* KEYBOARD_UpdateState
* X11DRV_KEYBOARD_UpdateState
*
* Update modifiers state (Ctrl, Alt, Shift)
* when window is activated (called by EVENT_FocusIn in event.c)
......@@ -178,7 +179,7 @@ void KEYBOARD_UpdateOneState ( int vkey, int state )
* Toggle keys are handled in HandleEvent. (because XQueryKeymap says nothing
* about them)
*/
void KEYBOARD_UpdateState ( void )
void X11DRV_KEYBOARD_UpdateState ( void )
{
/* extract a bit from the char[32] bit suite */
#define KeyState(keycode) ((keys_return[keycode/8] & (1<<(keycode%8)))!=0)
......@@ -199,11 +200,11 @@ void KEYBOARD_UpdateState ( void )
}
/***********************************************************************
* KEYBOARD_HandleEvent
* X11DRV_KEYBOARD_HandleEvent
*
* Handle a X key event
*/
void KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
void X11DRV_KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
{
char Str[24];
XComposeStatus cs;
......@@ -229,11 +230,11 @@ void KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
{
TRACE(key, "Alt Gr key event received\n");
event->keycode = kcControl; /* Simulate Control */
KEYBOARD_HandleEvent( pWnd, event );
X11DRV_KEYBOARD_HandleEvent( pWnd, event );
event->keycode = kcAlt; /* Simulate Alt */
force_extended = TRUE;
KEYBOARD_HandleEvent( pWnd, event );
X11DRV_KEYBOARD_HandleEvent( pWnd, event );
force_extended = FALSE;
return;
}
......
windows/x11drv/monitor.c 0 → 100644
View file @ ab121e78
/*
* X11 monitor driver
*
* Copyright 1998 Patrik Stridvall
*
*/
#include "config.h"
#ifndef X_DISPLAY_MISSING
#include <X11/cursorfont.h>
#include "ts_xlib.h"
#include "ts_xutil.h"
#include "debug.h"
#include "heap.h"
#include "monitor.h"
#include "options.h"
#include "wintypes.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
* FIXME
* The desktop should create created in X11DRV_DESKTOP_Initialize
* instead but it can't be yet because some code depends on that
* the desktop always exists.
*
*/
static void X11DRV_MONITOR_CreateDesktop(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor =
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
int x, y, flags;
unsigned int width = 640, height = 480; /* Default size = 640x480 */
char *name = "Wine desktop";
XSizeHints *size_hints;
XWMHints *wm_hints;
XClassHint *class_hints;
XSetWindowAttributes win_attr;
XTextProperty window_name;
Atom XA_WM_DELETE_WINDOW;
flags = TSXParseGeometry( Options.desktopGeometry, &x, &y, &width, &height );
pX11Monitor->width = width;
pX11Monitor->height = height;
/* Create window */
win_attr.background_pixel = BlackPixel(display, 0);
win_attr.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask |
PointerMotionMask | ButtonPressMask |
ButtonReleaseMask | EnterWindowMask;
win_attr.cursor = TSXCreateFontCursor( display, XC_top_left_arrow );
pX11Monitor->rootWindow =
TSXCreateWindow( display,
DefaultRootWindow(display),
x, y, width, height, 0,
CopyFromParent, InputOutput, CopyFromParent,
CWBackPixel | CWEventMask | CWCursor, &win_attr);
/* Set window manager properties */
size_hints = TSXAllocSizeHints();
wm_hints = TSXAllocWMHints();
class_hints = TSXAllocClassHint();
if (!size_hints || !wm_hints || !class_hints)
{
MSG("Not enough memory for window manager hints.\n" );
exit(1);
}
size_hints->min_width = size_hints->max_width = width;
size_hints->min_height = size_hints->max_height = height;
size_hints->flags = PMinSize | PMaxSize;
if (flags & (XValue | YValue)) size_hints->flags |= USPosition;
if (flags & (WidthValue | HeightValue)) size_hints->flags |= USSize;
else size_hints->flags |= PSize;
wm_hints->flags = InputHint | StateHint;
wm_hints->input = True;
wm_hints->initial_state = NormalState;
class_hints->res_name = Options.argv[0]; /* FIXME: Options.argv0 insteed? */
class_hints->res_class = "Wine";
TSXStringListToTextProperty( &name, 1, &window_name );
TSXSetWMProperties( display, pX11Monitor->rootWindow, &window_name, &window_name,
Options.argv, *Options.argc, size_hints, wm_hints, class_hints );
XA_WM_DELETE_WINDOW = TSXInternAtom( display, "WM_DELETE_WINDOW", False );
TSXSetWMProtocols( display, pX11Monitor->rootWindow, &XA_WM_DELETE_WINDOW, 1 );
TSXFree( size_hints );
TSXFree( wm_hints );
TSXFree( class_hints );
/* Map window */
TSXMapWindow( display, pX11Monitor->rootWindow );
}
/***********************************************************************
* X11DRV_MONITOR_Initialize
*/
void X11DRV_MONITOR_Initialize(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor = (X11DRV_MONITOR_DATA *)
HeapAlloc(SystemHeap, 0, sizeof(X11DRV_MONITOR_DATA));
int depth_count, i;
int *depth_list;
pMonitor->pDriverData = pX11Monitor;
pX11Monitor->screen = DefaultScreenOfDisplay( display );
pX11Monitor->width = WidthOfScreen( pX11Monitor->screen );
pX11Monitor->height = HeightOfScreen( pX11Monitor->screen );
pX11Monitor->depth = Options.screenDepth;
if (pX11Monitor->depth) /* -depth option 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)
{
MSG( "%s: Depth %d not supported on this screen.\n",
Options.programName, pX11Monitor->depth );
exit(1);
}
}
else
pX11Monitor->depth = DefaultDepthOfScreen( pX11Monitor->screen );
if (Options.synchronous) TSXSynchronize( display, True );
if (Options.desktopGeometry)
X11DRV_MONITOR_CreateDesktop(pMonitor);
else
pX11Monitor->rootWindow =
DefaultRootWindow( display );
}
/***********************************************************************
* X11DRV_MONITOR_Finalize
*/
void X11DRV_MONITOR_Finalize(MONITOR *pMonitor)
{
HeapFree(SystemHeap, 0, pMonitor->pDriverData);
}
/***********************************************************************
* X11DRV_MONITOR_GetWidth
*
* Return the width of the monitor
*/
int X11DRV_MONITOR_GetWidth(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor =
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return pX11Monitor->width;
}
/***********************************************************************
* X11DRV_MONITOR_GetHeight
*
* Return the height of the monitor
*/
int X11DRV_MONITOR_GetHeight(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor =
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return pX11Monitor->height;
}
/***********************************************************************
* X11DRV_MONITOR_GetDepth
*
* Return the depth of the monitor
*/
int X11DRV_MONITOR_GetDepth(MONITOR *pMonitor)
{
X11DRV_MONITOR_DATA *pX11Monitor =
(X11DRV_MONITOR_DATA *) pMonitor->pDriverData;
return pX11Monitor->depth;
}
#endif /* X_DISPLAY_MISSING */
windows/x11drv/mouse.c
View file @ ab121e78
......@@ -10,16 +10,18 @@
#include "ts_xlib.h"
#include "debug.h"
#include "callback.h"
#include "debug.h"
#include "display.h"
#include "win.h"
#include "wintypes.h"
#include "x11drv.h"
/**********************************************************************/
Cursor DISPLAY_XCursor = None; /* Current X cursor */
Cursor X11DRV_MOUSE_XCursor = None; /* Current X cursor */
BOOL32 DISPLAY_DisableWarpPointer = FALSE; /* hack; see DISPLAY_MoveCursor */
BOOL32 X11DRV_MOUSE_DisableWarpPointer = FALSE; /* hack; see DISPLAY_MoveCursor */
/***********************************************************************
* X11DRV_MOUSE_DoSetCursor
......@@ -35,7 +37,7 @@ static BOOL32 X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
static const char data[] = { 0 };
bg.red = bg.green = bg.blue = 0x0000;
pixmapBits = XCreateBitmapFromData( display, rootWindow, data, 1, 1 );
pixmapBits = XCreateBitmapFromData( display, X11DRV_GetXRootWindow(), data, 1, 1 );
if (pixmapBits)
{
cursor = XCreatePixmapCursor( display, pixmapBits, pixmapBits,
......@@ -60,9 +62,9 @@ static BOOL32 X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
* as the Windows cursor data). Perhaps use a more generic
* algorithm here.
*/
pixmapAll = XCreatePixmap( display, rootWindow,
pixmapAll = XCreatePixmap( display, X11DRV_GetXRootWindow(),
ptr->nWidth, ptr->nHeight * 2, 1 );
image = XCreateImage( display, DefaultVisualOfScreen(screen),
image = XCreateImage( display, DefaultVisualOfScreen(X11DRV_GetXScreen()),
1, ZPixmap, 0, (char *)(ptr + 1), ptr->nWidth,
ptr->nHeight * 2, 16, ptr->nWidthBytes);
if (image)
......@@ -80,9 +82,9 @@ static BOOL32 X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
/* Now create the 2 pixmaps for bits and mask */
pixmapBits = XCreatePixmap( display, rootWindow,
pixmapBits = XCreatePixmap( display, X11DRV_GetXRootWindow(),
ptr->nWidth, ptr->nHeight, 1 );
pixmapMask = XCreatePixmap( display, rootWindow,
pixmapMask = XCreatePixmap( display, X11DRV_GetXRootWindow(),
ptr->nWidth, ptr->nHeight, 1 );
/* Make sure everything went OK so far */
......@@ -136,13 +138,13 @@ static BOOL32 X11DRV_MOUSE_DoSetCursor( CURSORICONINFO *ptr )
}
if (cursor == None) return FALSE;
if (DISPLAY_XCursor != None) XFreeCursor( display, DISPLAY_XCursor );
DISPLAY_XCursor = cursor;
if (X11DRV_MOUSE_XCursor != None) XFreeCursor( display, X11DRV_MOUSE_XCursor );
X11DRV_MOUSE_XCursor = cursor;
if (rootWindow != DefaultRootWindow(display) || !WIN_GetDesktop())
if (X11DRV_GetXRootWindow() != DefaultRootWindow(display) || !WIN_GetDesktop())
{
/* Set the cursor on the desktop window */
XDefineCursor( display, rootWindow, cursor );
XDefineCursor( display, X11DRV_GetXRootWindow(), cursor );
}
else
{
......@@ -198,9 +200,9 @@ void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY)
int rootX, rootY, winX, winY;
unsigned int xstate;
if (DISPLAY_DisableWarpPointer) return;
if (X11DRV_MOUSE_DisableWarpPointer) return;
if (!TSXQueryPointer( display, rootWindow, &root, &child,
if (!TSXQueryPointer( display, X11DRV_GetXRootWindow(), &root, &child,
&rootX, &rootY, &winX, &winY, &xstate ))
return;
......@@ -209,7 +211,8 @@ void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY)
TRACE( cursor, "(%d,%d): moving from (%d,%d)\n", wAbsX, wAbsY, winX, winY );
TSXWarpPointer( display, rootWindow, rootWindow, 0, 0, 0, 0, wAbsX, wAbsY );
TSXWarpPointer( display, X11DRV_GetXRootWindow(), X11DRV_GetXRootWindow(),
0, 0, 0, 0, wAbsX, wAbsY );
}
#endif /* !defined(X_DISPLAY_MISSING) */
windows/x11drv/wnd.c
View file @ ab121e78
......@@ -25,11 +25,12 @@
#include "heap.h"
#include "win.h"
#include "wintypes.h"
#include "class.h"
#include "x11drv.h"
/**********************************************************************/
extern Cursor DISPLAY_XCursor; /* Current X cursor */
extern Cursor X11DRV_MOUSE_XCursor; /* Current X cursor */
/**********************************************************************/
......@@ -67,16 +68,38 @@ Window X11DRV_WND_FindXWindow(WND *wndPtr)
}
/***********************************************************************
* 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
*
* Associate an X window to a HWND.
*/
static void X11DRV_WND_RegisterWindow(WND *pWnd)
static void X11DRV_WND_RegisterWindow(WND *wndPtr)
{
TSXSetWMProtocols( display, X11DRV_WND_GetXWindow(pWnd), &wmDeleteWindow, 1 );
TSXSetWMProtocols( display, X11DRV_WND_GetXWindow(wndPtr), &wmDeleteWindow, 1 );
if (!winContext) winContext = TSXUniqueContext();
TSXSaveContext( display, X11DRV_WND_GetXWindow(pWnd), winContext, (char *)pWnd );
TSXSaveContext( display, X11DRV_WND_GetXWindow(wndPtr), winContext, (char *) wndPtr );
}
/**********************************************************************
......@@ -130,7 +153,8 @@ BOOL32 X11DRV_WND_CreateDesktopWindow(WND *wndPtr, CLASS *classPtr, BOOL32 bUnic
if( dndSelection == None )
dndSelection = TSXInternAtom( display, "DndSelection" , False );
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = rootWindow;
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window =
X11DRV_WND_GetXRootWindow( wndPtr );
X11DRV_WND_RegisterWindow( wndPtr );
return TRUE;
......@@ -144,7 +168,8 @@ BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs
/* Create the X window (only for top-level windows, and then only */
/* when there's no desktop window) */
if (!(cs->style & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
if (!(cs->style & WS_CHILD) &&
(X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display)))
{
XSetWindowAttributes win_attr;
......@@ -166,13 +191,15 @@ BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs
FocusChangeMask;
win_attr.override_redirect = TRUE;
}
win_attr.colormap = COLOR_GetColormap();
win_attr.colormap = X11DRV_COLOR_GetColormap();
win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful;
win_attr.save_under = ((classPtr->style & CS_SAVEBITS) != 0);
win_attr.cursor = DISPLAY_XCursor;
win_attr.cursor = X11DRV_MOUSE_XCursor;
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window =
TSXCreateWindow( display, rootWindow, cs->x, cs->y,
cs->cx, cs->cy, 0, CopyFromParent,
TSXCreateWindow( display,
X11DRV_WND_GetXRootWindow(wndPtr),
cs->x, cs->y, cs->cx, cs->cy,
0, CopyFromParent,
InputOutput, CopyFromParent,
CWEventMask | CWOverrideRedirect |
CWColormap | CWCursor | CWSaveUnder |
......@@ -218,15 +245,15 @@ BOOL32 X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCT32A *cs
/***********************************************************************
* X11DRV_WND_DestroyWindow
*/
BOOL32 X11DRV_WND_DestroyWindow(WND *pWnd)
BOOL32 X11DRV_WND_DestroyWindow(WND *wndPtr)
{
if (X11DRV_WND_GetXWindow(pWnd))
if (X11DRV_WND_GetXWindow(wndPtr))
{
XEvent xe;
TSXDeleteContext( display, X11DRV_WND_GetXWindow(pWnd), winContext );
TSXDestroyWindow( display, X11DRV_WND_GetXWindow(pWnd) );
while( TSXCheckWindowEvent(display, X11DRV_WND_GetXWindow(pWnd), NoEventMask, &xe) );
((X11DRV_WND_DATA *) pWnd->pDriverData)->window = None;
TSXDeleteContext( display, X11DRV_WND_GetXWindow(wndPtr), winContext );
TSXDestroyWindow( display, X11DRV_WND_GetXWindow(wndPtr) );
while( TSXCheckWindowEvent(display, X11DRV_WND_GetXWindow(wndPtr), NoEventMask, &xe) );
((X11DRV_WND_DATA *) wndPtr->pDriverData)->window = None;
}
return TRUE;
......@@ -265,7 +292,7 @@ WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
{
wndPtr->dwStyle &= ~WS_CHILD;
wndPtr->wIDmenu = 0;
if( rootWindow == DefaultRootWindow(display) )
if( X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display) )
{
CREATESTRUCT32A cs;
cs.lpCreateParams = NULL;
......@@ -315,28 +342,28 @@ WND *X11DRV_WND_SetParent(WND *wndPtr, WND *pWndParent)
* Raise a window on top of the X stacking order, while preserving
* the correct Windows Z order.
*/
void X11DRV_WND_ForceWindowRaise(WND *pWnd)
void X11DRV_WND_ForceWindowRaise(WND *wndPtr)
{
XWindowChanges winChanges;
WND *wndPrev;
if( !pWnd || !X11DRV_WND_GetXWindow(pWnd) || (pWnd->flags & WIN_MANAGED) )
if( !wndPtr || !X11DRV_WND_GetXWindow(wndPtr) || (wndPtr->flags & WIN_MANAGED) )
return;
/* Raise all windows up to pWnd according to their Z order.
/* Raise all windows up to wndPtr according to their Z order.
* (it would be easier with sibling-related Below but it doesn't
* work very well with SGI mwm for instance)
*/
winChanges.stack_mode = Above;
while (pWnd)
while (wndPtr)
{
if (X11DRV_WND_GetXWindow(pWnd))
TSXReconfigureWMWindow( display, X11DRV_WND_GetXWindow(pWnd), 0,
if (X11DRV_WND_GetXWindow(wndPtr))
TSXReconfigureWMWindow( display, X11DRV_WND_GetXWindow(wndPtr), 0,
CWStackMode, &winChanges );
wndPrev = WIN_GetDesktop()->child;
if (wndPrev == pWnd) break;
while (wndPrev && (wndPrev->next != pWnd)) wndPrev = wndPrev->next;
pWnd = wndPrev;
if (wndPrev == wndPtr) break;
while (wndPrev && (wndPrev->next != wndPtr)) wndPrev = wndPrev->next;
wndPtr = wndPrev;
}
}
......@@ -377,6 +404,8 @@ void X11DRV_WND_SetWindowPos(WND *wndPtr, const WINDOWPOS32 *winpos, BOOL32 bSMC
XWindowChanges winChanges;
int changeMask = 0;
WND *winposPtr = WIN_FindWndPtr( winpos->hwnd );
if(!wndPtr->hwndSelf) wndPtr = NULL; /* FIXME: WND destroyed, shouldn't happend!!! */
if (!(winpos->flags & SWP_SHOWWINDOW) && (winpos->flags & SWP_HIDEWINDOW))
{
......@@ -477,12 +506,13 @@ void X11DRV_WND_SetFocus(WND *wndPtr)
/* Only mess with the X focus if there's */
/* no desktop window and no window manager. */
if ((rootWindow != DefaultRootWindow(display)) || Options.managed) return;
if ((X11DRV_WND_GetXRootWindow(wndPtr) != DefaultRootWindow(display))
|| Options.managed) return;
if (!hwnd) /* If setting the focus to 0, uninstall the colormap */
{
if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
TSXUninstallColormap( display, COLOR_GetColormap() );
TSXUninstallColormap( display, X11DRV_COLOR_GetColormap() );
return;
}
......@@ -495,7 +525,7 @@ void X11DRV_WND_SetFocus(WND *wndPtr)
TSXSetInputFocus( display, win, RevertToParent, CurrentTime );
if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
TSXInstallColormap( display, COLOR_GetColormap() );
TSXInstallColormap( display, X11DRV_COLOR_GetColormap() );
EVENT_Synchronize();
}
......@@ -505,7 +535,8 @@ void X11DRV_WND_SetFocus(WND *wndPtr)
*/
void X11DRV_WND_PreSizeMove(WND *wndPtr)
{
if (!(wndPtr->dwStyle & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
if (!(wndPtr->dwStyle & WS_CHILD) &&
(X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display)))
TSXGrabServer( display );
}
......@@ -514,7 +545,8 @@ void X11DRV_WND_PreSizeMove(WND *wndPtr)
*/
void X11DRV_WND_PostSizeMove(WND *wndPtr)
{
if (!(wndPtr->dwStyle & WS_CHILD) && (rootWindow == DefaultRootWindow(display)))
if (!(wndPtr->dwStyle & WS_CHILD) &&
(X11DRV_GetXRootWindow(wndPtr) == DefaultRootWindow(display)))
TSXUngrabServer( display );
}
......@@ -566,7 +598,7 @@ void X11DRV_WND_SetDrawable(WND *wndPtr, DC *dc, WORD flags, BOOL32 bSetClipOrig
{
dc->w.DCOrgX = 0;
dc->w.DCOrgY = 0;
physDev->drawable = rootWindow;
physDev->drawable = X11DRV_WND_GetXRootWindow(wndPtr);
TSXSetSubwindowMode( display, physDev->gc, IncludeInferiors );
}
else
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment