* 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>
#include "options.h"
#include "x11drv.h"
#include "debug.h"
-#include "xmalloc.h"
+#include "xmalloc.h" /* for XCREATEIMAGE macro */
#define DST 0 /* Destination drawable */
/* 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 );
}
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,
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 */
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 */
DIB_UpdateDIBSection( dcDst, TRUE );
return result;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
* 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;
/* 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 );
/* 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 );
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");
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);
return TRUE;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
* Copyright 1993, 1994 Alexandre Julliard
*/
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
+
#include "ts_xlib.h"
#include <stdlib.h>
#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] =
{
*/
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);
}
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 );
{
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 );
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 );
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;
return prevHandle;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
+
* Copyright 1998 Huw Davies
*/
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
+
#include "ts_xlib.h"
#include <stdio.h>
#include "region.h"
#include "debug.h"
#include "heap.h"
+#include "local.h"
/***********************************************************************
* X11DRV_SetDeviceClipping
GDI_HEAP_UNLOCK( dc->w.hGCClipRgn );
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
+
* 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 };
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;
HeapFree(GetProcessHeap(), 0, descr.colorMap);
return result;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
* 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
#include "bitmap.h"
#include "gdi.h"
#include "dc.h"
+#include "monitor.h"
#include "bitmap.h"
#include "callback.h"
#include "metafile.h"
*/
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;
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++)
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 :
/* 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 :
{
/* 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 );
return oldColor;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
* Copyright 1996 Alexandre Julliard
*/
+#include "config.h"
+
+#ifndef X_DISPLAY_MISSING
+
#include "ts_xlib.h"
#include <string.h>
#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 );
#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;
}
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 );
}
return 0;
}
+#endif /* !defined(X_DISPLAY_MISSING) */
* 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"
GDI_HEAP_UNLOCK( handle );
return ret;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
*
*/
-#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"
/* 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) },
/* 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
*
* Allocate a GDI bitmap.
*/
+#ifdef HAVE_LIBXXPM
static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
WORD bpp, Pixmap pixmap )
{
GDI_HEAP_UNLOCK( hbitmap );
return hbitmap;
}
-
+#endif /* defined(HAVE_LIBXXPM) */
/***********************************************************************
* OBM_CreateBitmaps
*/
static BOOL32 OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr )
{
+#ifdef HAVE_LIBXXPM
Pixmap pixmap, pixmask;
XpmAttributes *attrs;
int err;
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)
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) */
}
return 1;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
* 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 }; /* ----- ----- ----- */
return prevHandle;
}
+
+#endif /* !defined(X_DISPLAY_MISSING) */
* 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; }
return TRUE;
}
+#endif /* !defined(X_DISPLAY_MISSING) */
* 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>
#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)
return FALSE;
}
+#endif /* !defined(X_DISPLAY_MISSING) */
+
/***********************************************************************
* *
* Font Resource API *
return TRUE;
}
-
C_SRCS = \
clipboard.c \
+ desktop.c \
event.c \
init.c \
keyboard.c \
+ main.c \
+ monitor.c \
mouse.c \
wnd.c
#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;
--- /dev/null
+/*
+ * 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 */
#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;
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 */
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;
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;
*/
static void EVENT_Key( WND *pWnd, XKeyEvent *event )
{
- KEYBOARD_HandleEvent( pWnd, event );
+ X11DRV_KEYBOARD_HandleEvent( pWnd, event );
}
if (hwnd != GetActiveWindow32())
{
WINPOS_ChangeActiveWindow( hwnd, FALSE );
- KEYBOARD_UpdateState();
+ X11DRV_KEYBOARD_UpdateState();
}
if ((hwnd != GetFocus32()) && !IsChild32( hwnd, GetFocus32()))
SetFocus32( hwnd );
if (!TSXGetGeometry( display, win, &root, px, py, pwidth, pheight,
&border, &depth )) return;
- if (win == rootWindow)
+ if (win == X11DRV_GetXRootWindow())
{
*px = *py = 0;
return;
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;
}
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 );
#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
}
#endif /* !defined(X_DISPLAY_MISSING) */
-
-
-
#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,
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 =
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) */
#include "ts_xutil.h"
#include "debug.h"
+#include "keyboard.h"
#include "message.h"
#include "wintypes.h"
#include "x11drv.h"
}
/***********************************************************************
- * KEYBOARD_UpdateState
+ * X11DRV_KEYBOARD_UpdateState
*
* Update modifiers state (Ctrl, Alt, Shift)
* when window is activated (called by EVENT_FocusIn in event.c)
* 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)
}
/***********************************************************************
- * 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;
{
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;
}
--- /dev/null
+/*
+ * 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 "console.h"
+#include "debug.h"
+#include "desktop.h"
+#include "main.h"
+#include "monitor.h"
+#include "options.h"
+#include "win.h"
+#include "wintypes.h"
+#include "x11drv.h"
+#include "xmalloc.h"
+#include "version.h"
+
+/**********************************************************************/
+
+#define WINE_CLASS "Wine" /* Class name for resources */
+#define WINE_APP_DEFAULTS "/usr/lib/X11/app-defaults/Wine"
+
+static XrmOptionDescRec optionsTable[] =
+{
+ { "-backingstore", ".backingstore", XrmoptionNoArg, (caddr_t)"on" },
+ { "-desktop", ".desktop", XrmoptionSepArg, (caddr_t)NULL },
+ { "-depth", ".depth", XrmoptionSepArg, (caddr_t)NULL },
+ { "-display", ".display", XrmoptionSepArg, (caddr_t)NULL },
+ { "-iconic", ".iconic", XrmoptionNoArg, (caddr_t)"on" },
+ { "-language", ".language", XrmoptionSepArg, (caddr_t)"En" },
+ { "-name", ".name", XrmoptionSepArg, (caddr_t)NULL },
+ { "-perfect", ".perfect", XrmoptionNoArg, (caddr_t)"on" },
+ { "-privatemap", ".privatemap", XrmoptionNoArg, (caddr_t)"on" },
+ { "-fixedmap", ".fixedmap", XrmoptionNoArg, (caddr_t)"on" },
+ { "-synchronous", ".synchronous", XrmoptionNoArg, (caddr_t)"on" },
+ { "-debug", ".debug", XrmoptionNoArg, (caddr_t)"on" },
+ { "-debugmsg", ".debugmsg", XrmoptionSepArg, (caddr_t)NULL },
+ { "-dll", ".dll", XrmoptionSepArg, (caddr_t)NULL },
+ { "-failreadonly", ".failreadonly", XrmoptionNoArg, (caddr_t)"on" },
+ { "-mode", ".mode", XrmoptionSepArg, (caddr_t)NULL },
+ { "-managed", ".managed", XrmoptionNoArg, (caddr_t)"off"},
+ { "-winver", ".winver", XrmoptionSepArg, (caddr_t)NULL },
+ { "-config", ".config", XrmoptionSepArg, (caddr_t)NULL },
+ { "-nodga", ".nodga", XrmoptionNoArg, (caddr_t)"off"},
+ { "-console", ".console", XrmoptionSepArg, (caddr_t)NULL },
+ { "-dosver", ".dosver", XrmoptionSepArg, (caddr_t)NULL }
+};
+
+#define NB_OPTIONS (sizeof(optionsTable) / sizeof(optionsTable[0]))
+
+/**********************************************************************/
+
+static XKeyboardState X11DRV_XKeyboardState;
+Display *display;
+
+/***********************************************************************
+ * 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);
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_Initialize
+ */
+void X11DRV_MAIN_Initialize()
+{
+ /* We need this before calling any Xlib function */
+ InitializeCriticalSection( &X11DRV_CritSection );
+ MakeCriticalSectionGlobal( &X11DRV_CritSection );
+
+ TSXrmInitialize();
+
+ putenv("XKB_DISABLE="); /* Disable XKB extension if present. */
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_Finalize
+ */
+void X11DRV_MAIN_Finalize()
+{
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_GetResource
+ *
+ * Fetch the value of resource 'name' using the correct instance name.
+ * 'name' must begin with '.' or '*'
+ */
+static int X11DRV_MAIN_GetResource( XrmDatabase db, char *name, XrmValue *value )
+{
+ char *buff_instance, *buff_class;
+ char *dummy;
+ int retval;
+
+ buff_instance = (char *)xmalloc(strlen(Options.programName)+strlen(name)+1);
+ buff_class = (char *)xmalloc( strlen(WINE_CLASS) + strlen(name) + 1 );
+
+ strcpy( buff_instance, Options.programName );
+ strcat( buff_instance, name );
+ strcpy( buff_class, WINE_CLASS );
+ strcat( buff_class, name );
+ retval = TSXrmGetResource( db, buff_instance, buff_class, &dummy, value );
+ free( buff_instance );
+ free( buff_class );
+ return retval;
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_ParseOptions
+ * Parse command line options and open display.
+ */
+void X11DRV_MAIN_ParseOptions(int *argc, char *argv[])
+{
+ int i;
+ char *display_name = NULL;
+ XrmValue value;
+ XrmDatabase db = TSXrmGetFileDatabase(WINE_APP_DEFAULTS);
+ char *xrm_string;
+
+ /* Get display name from command line */
+ for (i = 1; i < *argc; i++)
+ {
+ if (!strcmp( argv[i], "-display" )) display_name = argv[i+1];
+ }
+
+ /* Open display */
+
+ if (display_name == NULL &&
+ X11DRV_MAIN_GetResource( db, ".display", &value )) display_name = value.addr;
+
+ if (!(display = TSXOpenDisplay( display_name )))
+ {
+ MSG( "%s: Can't open display: %s\n",
+ argv[0], display_name ? display_name : "(none specified)" );
+ exit(1);
+ }
+
+ /* tell the libX11 that we will do input method handling ourselves
+ * that keep libX11 from doing anything whith dead keys, allowing Wine
+ * to have total control over dead keys, that is this line allows
+ * them to work in Wine, even whith a libX11 including the dead key
+ * patches from Th.Quinot (http://Web.FdN.FR/~tquinot/dead-keys.en.html)
+ */
+ TSXOpenIM(display,NULL,NULL,NULL);
+
+ /* Merge file and screen databases */
+ if ((xrm_string = TSXResourceManagerString( display )) != NULL)
+ {
+ XrmDatabase display_db = TSXrmGetStringDatabase( xrm_string );
+ TSXrmMergeDatabases( display_db, &db );
+ }
+
+ /* Parse command line */
+ TSXrmParseCommand( &db, optionsTable, NB_OPTIONS,
+ Options.programName, argc, argv );
+
+ /* Get all options */
+ if (X11DRV_MAIN_GetResource( db, ".iconic", &value ))
+ Options.cmdShow = SW_SHOWMINIMIZED;
+ if (X11DRV_MAIN_GetResource( db, ".privatemap", &value ))
+ Options.usePrivateMap = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".fixedmap", &value ))
+ Options.useFixedMap = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".synchronous", &value ))
+ Options.synchronous = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".backingstore", &value ))
+ Options.backingstore = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".debug", &value ))
+ Options.debug = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".failreadonly", &value ))
+ Options.failReadOnly = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".perfect", &value ))
+ Options.perfectGraphics = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".depth", &value))
+ Options.screenDepth = atoi( value.addr );
+ if (X11DRV_MAIN_GetResource( db, ".desktop", &value))
+ Options.desktopGeometry = value.addr;
+ if (X11DRV_MAIN_GetResource( db, ".language", &value))
+ MAIN_ParseLanguageOption( (char *)value.addr );
+ if (X11DRV_MAIN_GetResource( db, ".managed", &value))
+ Options.managed = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".mode", &value))
+ MAIN_ParseModeOption( (char *)value.addr );
+ if (X11DRV_MAIN_GetResource( db, ".debugoptions", &value))
+ MAIN_ParseDebugOptions((char*)value.addr);
+ if (X11DRV_MAIN_GetResource( db, ".debugmsg", &value))
+ {
+#ifndef DEBUG_RUNTIME
+ MSG("%s: Option \"-debugmsg\" not implemented.\n" \
+ " Recompile with DEBUG_RUNTIME in include/debugtools.h defined.\n",
+ argv[0]);
+ exit(1);
+#else
+ MAIN_ParseDebugOptions((char*)value.addr);
+#endif
+ }
+
+ if (X11DRV_MAIN_GetResource( db, ".dll", &value))
+ {
+ /* Hack: store option value in Options to be retrieved */
+ /* later on inside the emulator code. */
+ if (!__winelib)
+ {
+ if (Options.dllFlags)
+ {
+ /* don't overwrite previous value. Should we
+ * automatically add the ',' between multiple DLLs ?
+ */
+ MSG("Only one -dll flag is allowed. Use ',' between multiple DLLs\n");
+ }
+ else
+ {
+ Options.dllFlags = xstrdup((char *)value.addr);
+ }
+ }
+ else
+ {
+ MSG("-dll not supported in Winelib\n" );
+ exit(1);
+ }
+ }
+
+ if (X11DRV_MAIN_GetResource( db, ".winver", &value))
+ VERSION_ParseWinVersion( (char*)value.addr );
+ if (X11DRV_MAIN_GetResource( db, ".dosver", &value))
+ VERSION_ParseDosVersion( (char*)value.addr );
+ if (X11DRV_MAIN_GetResource( db, ".config", &value))
+ Options.configFileName = xstrdup((char *)value.addr);
+ if (X11DRV_MAIN_GetResource( db, ".nodga", &value))
+ Options.noDGA = TRUE;
+ if (X11DRV_MAIN_GetResource( db, ".console", &value))
+ Options.consoleDrivers = xstrdup((char *)value.addr);
+ else
+ Options.consoleDrivers = CONSOLE_DEFAULT_DRIVER;
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_ErrorHandler
+ */
+static int X11DRV_MAIN_ErrorHandler(Display *display, XErrorEvent *error_evt)
+{
+ kill( getpid(), SIGHUP ); /* force an entry in the debugger */
+ return 0;
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_Create
+ */
+void X11DRV_MAIN_Create()
+{
+ if (Options.synchronous) XSetErrorHandler( X11DRV_MAIN_ErrorHandler );
+
+ if (Options.desktopGeometry && Options.managed)
+ {
+#if 0
+ MSG( "%s: -managed and -desktop options cannot be used together\n",
+ Options.programName );
+ exit(1);
+#else
+ Options.managed = FALSE;
+#endif
+ }
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_SaveSetup
+ */
+void X11DRV_MAIN_SaveSetup()
+{
+ TSXGetKeyboardControl(display, &X11DRV_XKeyboardState);
+}
+
+/***********************************************************************
+ * X11DRV_MAIN_RestoreSetup
+ */
+void X11DRV_MAIN_RestoreSetup()
+{
+ XKeyboardControl keyboard_value;
+
+ keyboard_value.key_click_percent = X11DRV_XKeyboardState.key_click_percent;
+ keyboard_value.bell_percent = X11DRV_XKeyboardState.bell_percent;
+ keyboard_value.bell_pitch = X11DRV_XKeyboardState.bell_pitch;
+ keyboard_value.bell_duration = X11DRV_XKeyboardState.bell_duration;
+ keyboard_value.auto_repeat_mode = X11DRV_XKeyboardState.global_auto_repeat;
+
+ XChangeKeyboardControl(display, KBKeyClickPercent | KBBellPercent |
+ KBBellPitch | KBBellDuration | KBAutoRepeatMode, &keyboard_value);
+}
+
+#endif /* X_DISPLAY_MISSING */
--- /dev/null
+/*
+ * 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 */
+
+
#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
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,
* 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)
/* 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 */
}
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
{
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;
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) */
#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 */
/**********************************************************************/
((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
*
* 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 );
}
/**********************************************************************
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;
/* 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;
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 |
/***********************************************************************
* 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;
{
wndPtr->dwStyle &= ~WS_CHILD;
wndPtr->wIDmenu = 0;
- if( rootWindow == DefaultRootWindow(display) )
+ if( X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display) )
{
CREATESTRUCT32A cs;
cs.lpCreateParams = NULL;
* 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;
}
}
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))
{
/* 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;
}
TSXSetInputFocus( display, win, RevertToParent, CurrentTime );
if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE)
- TSXInstallColormap( display, COLOR_GetColormap() );
+ TSXInstallColormap( display, X11DRV_COLOR_GetColormap() );
EVENT_Synchronize();
}
*/
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 );
}
*/
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 );
}
{
dc->w.DCOrgX = 0;
dc->w.DCOrgY = 0;
- physDev->drawable = rootWindow;
+ physDev->drawable = X11DRV_WND_GetXRootWindow(wndPtr);
TSXSetSubwindowMode( display, physDev->gc, IncludeInferiors );
}
else
projects / wine / commitdiff
