diff --git a/controls/desktop.c b/controls/desktop.c index f2573f820699d4e1717877d53cdc89e9b763dc02..50a9fd19d6b49cb7354b2a833c028c2c395db0cf 100644 --- a/controls/desktop.c +++ b/controls/desktop.c @@ -4,8 +4,6 @@ * Copyright 1994 Alexandre Julliard */ -#include "x11drv.h" - #include <stdio.h> #include <string.h> #include <unistd.h> @@ -17,6 +15,19 @@ #include "win.h" #include "wine/winuser16.h" +/**********************************************************************/ + +DESKTOP_DRIVER *DESKTOP_Driver = NULL; + +/*********************************************************************** + * DESKTOP_IsSingleWindow + */ +BOOL DESKTOP_IsSingleWindow() +{ + DESKTOP *pDesktop = (DESKTOP *) WIN_GetDesktop()->wExtra; + return MONITOR_IsSingleWindow(pDesktop->pPrimaryMonitor); +} + /*********************************************************************** * DESKTOP_GetScreenWidth * @@ -206,8 +217,7 @@ LRESULT WINAPI DesktopWndProc( HWND hwnd, UINT message, goto END; case WM_ERASEBKGND: - if (X11DRV_WND_GetXRootWindow(wndPtr) == - DefaultRootWindow(display)) + if(!DESKTOP_IsSingleWindow()) { retvalue = 1; goto END; diff --git a/debugger/dbg.y b/debugger/dbg.y index 849ab849418cbf946e88588c98de7c7280e0b0f8..aabfa8e1b7eb18e9285fdc6c3271238605af520e 100644 --- a/debugger/dbg.y +++ b/debugger/dbg.y @@ -6,16 +6,13 @@ * Copyright 1995 Morten Welinder */ -#include "config.h" -#include "ts_xlib.h" -#include "x11drv.h" - #include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal.h> #include <sys/stat.h> #include <unistd.h> + #include "winbase.h" #include "class.h" #include "module.h" @@ -30,6 +27,7 @@ #include "process.h" #include "main.h" #include "expr.h" +#include "user.h" extern FILE * yyin; unsigned int dbg_mode = 0; @@ -494,9 +492,7 @@ static void DEBUG_Main( int signal ) GlobalUnlock16( GetCurrentTask() ); /* Put the display in a correct state */ - - TSXUngrabServer( display ); - TSXFlush( display ); + USER_Driver->pBeginDebugging(); newmode = ISV86(&DEBUG_context) ? 16 : IS_SELECTOR_32BIT(addr.seg) ? 32 : 16; if (newmode != dbg_mode) @@ -569,6 +565,8 @@ static void DEBUG_Main( int signal ) } in_debugger = FALSE; + + USER_Driver->pEndDebugging(); } diff --git a/graphics/metafiledrv/init.c b/graphics/metafiledrv/init.c index 197d5d5bf779c0184db8835c9bb9dc36faa0c6c5..c7195d3517382b129fde080415c9c2bb193b5e26 100644 --- a/graphics/metafiledrv/init.c +++ b/graphics/metafiledrv/init.c @@ -24,6 +24,8 @@ static const DC_FUNCTIONS MFDRV_Funcs = NULL, /* pCreateBitmap */ NULL, /* no implementation */ /* pCreateDC */ NULL, /* no implementation */ /* pDeleteDC */ + NULL, /* pCreateDIBSection */ + NULL, /* pCreateDIBSection16 */ NULL, /* pDeleteObject */ MFDRV_Ellipse, /* pEllipse */ NULL, /* pEnumDeviceFonts */ diff --git a/graphics/psdrv/init.c b/graphics/psdrv/init.c index aa4cac755a7cd0ac97eb7a9076064544be26f969..b12ff688ca67aa4606cba165d611c8a71d8ea28c 100644 --- a/graphics/psdrv/init.c +++ b/graphics/psdrv/init.c @@ -27,6 +27,8 @@ static const DC_FUNCTIONS PSDRV_Funcs = NULL, /* pCreateBitmap */ PSDRV_CreateDC, /* pCreateDC */ PSDRV_DeleteDC, /* pDeleteDC */ + NULL, /* pCreateDIBSection */ + NULL, /* pCreateDIBSection16 */ NULL, /* pDeleteObject */ PSDRV_Ellipse, /* pEllipse */ PSDRV_EnumDeviceFonts, /* pEnumDeviceFonts */ diff --git a/graphics/ttydrv/Makefile.in b/graphics/ttydrv/Makefile.in index 662e54825b0180c1e2561398f8b2320a499ffab6..d667c9fa0410b378ca5f2b7c7a433a09a6def469 100644 --- a/graphics/ttydrv/Makefile.in +++ b/graphics/ttydrv/Makefile.in @@ -6,7 +6,9 @@ VPATH = @srcdir@ MODULE = ttydrv C_SRCS = \ - init.c + bitmap.c \ + init.c \ + palette.c all: $(MODULE).o diff --git a/graphics/ttydrv/bitmap.c b/graphics/ttydrv/bitmap.c new file mode 100644 index 0000000000000000000000000000000000000000..94c3cd896be244ad48572169a99a5b37fc07509d --- /dev/null +++ b/graphics/ttydrv/bitmap.c @@ -0,0 +1,56 @@ +/* + * TTY bitmap driver + * + * Copyright 1999 Patrik Stridvall + */ + +#include "dc.h" +#include "bitmap.h" +#include "ttydrv.h" + +/********************************************************************** + * TTYDRV_BITMAP_CreateDIBSection + */ +HBITMAP TTYDRV_BITMAP_CreateDIBSection( + DC *dc, BITMAPINFO *bmi, UINT usage, + LPVOID *bits, HANDLE section, DWORD offset) +{ + return (HBITMAP) NULL; +} + +/********************************************************************** + * TTYDRV_BITMAP_CreateDIBSection16 + */ +HBITMAP16 TTYDRV_DIB_CreateDIBSection16( + DC *dc, BITMAPINFO *bmi, UINT16 usage, + SEGPTR *bits, HANDLE section, DWORD offset) +{ + return (HBITMAP16) NULL; +} + +/********************************************************************** + * TTYDRV_BITMAP_SetDIBits + */ +INT TTYDRV_BITMAP_SetDIBits( + BITMAPOBJ *bmp, DC *dc, UINT startscan, UINT lines, + LPCVOID bits, const BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap) +{ + return 0; +} + +/********************************************************************** + * TTYDRV_BITMAP_GetDIBits + */ +INT TTYDRV_BITMAP_GetDIBits( + BITMAPOBJ *bmp, DC *dc, UINT startscan, UINT lines, + LPVOID bits, BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap) +{ + return 0; +} + +/********************************************************************** + * TTYDRV_BITMAP_DeleteDIBSection + */ +void TTYDRV_BITMAP_DeleteDIBSection(BITMAPOBJ *bmp) +{ +} diff --git a/graphics/ttydrv/init.c b/graphics/ttydrv/init.c index 5f4dcf47d127670d5a746a375ff1fceee83b9b99..680419ad2098037e0e80ccf988ac1cfee7f1cd9b 100644 --- a/graphics/ttydrv/init.c +++ b/graphics/ttydrv/init.c @@ -4,25 +4,30 @@ * Copyright 1998 Patrik Stridvall */ +#include "gdi.h" +#include "bitmap.h" #include "color.h" #include "dc.h" #include "debug.h" #include "heap.h" +#include "palette.h" #include "ttydrv.h" -static const DC_FUNCTIONS TTYDRV_GDI_Driver = +static const DC_FUNCTIONS TTYDRV_DC_Driver = { NULL, /* pArc */ NULL, /* pBitBlt */ NULL, /* pBitmapBits */ NULL, /* pChord */ NULL, /* pCreateBitmap */ - TTYDRV_GDI_CreateDC, /* pCreateDC */ - TTYDRV_GDI_DeleteDC, /* pDeleteDC */ + TTYDRV_DC_CreateDC, /* pCreateDC */ + TTYDRV_DC_DeleteDC, /* pDeleteDC */ + NULL, /* pCreateDIBSection */ + NULL, /* pCreateDIBSection16 */ NULL, /* pDeleteObject */ NULL, /* pEllipse */ NULL, /* pEnumDeviceFonts */ - TTYDRV_GDI_Escape, /* pEscape */ + TTYDRV_DC_Escape, /* pEscape */ NULL, /* pExcludeClipRect */ NULL, /* pExcludeVisRect */ NULL, /* pExtFloodFill */ @@ -80,9 +85,29 @@ static const DC_FUNCTIONS TTYDRV_GDI_Driver = NULL /* pStretchDIBits */ }; + +GDI_DRIVER TTYDRV_GDI_Driver = +{ + TTYDRV_GDI_Initialize, + TTYDRV_GDI_Finalize +}; + +BITMAP_DRIVER TTYDRV_BITMAP_Driver = +{ + TTYDRV_BITMAP_SetDIBits, + TTYDRV_BITMAP_GetDIBits, + TTYDRV_BITMAP_DeleteDIBSection +}; + +PALETTE_DRIVER TTYDRV_PALETTE_Driver = +{ + TTYDRV_PALETTE_SetMapping, + TTYDRV_PALETTE_UpdateMapping +}; + /* FIXME: Adapt to the TTY driver. Copied from the X11 driver */ -static DeviceCaps TTYDRV_GDI_DevCaps = { +static DeviceCaps TTYDRV_DC_DevCaps = { /* version */ 0, /* technology */ DT_RASDISPLAY, /* size, resolution */ 0, 0, 0, 0, 0, @@ -110,37 +135,41 @@ static DeviceCaps TTYDRV_GDI_DevCaps = { */ BOOL TTYDRV_GDI_Initialize(void) { - - TTYDRV_GDI_DevCaps.version = 0x300; - TTYDRV_GDI_DevCaps.horzSize = 0; /* FIXME: Screen width in mm */ - TTYDRV_GDI_DevCaps.vertSize = 0; /* FIXME: Screen height in mm */ - TTYDRV_GDI_DevCaps.horzRes = 640; /* FIXME: Screen width in pixel */ - TTYDRV_GDI_DevCaps.vertRes = 480; /* FIXME: Screen height in pixel */ - TTYDRV_GDI_DevCaps.bitsPixel = 1; /* FIXME: Bits per pixel */ - TTYDRV_GDI_DevCaps.sizePalette = 0; /* FIXME: ??? */ + BITMAP_Driver = &TTYDRV_BITMAP_Driver; + PALETTE_Driver = &TTYDRV_PALETTE_Driver; + + TTYDRV_DC_DevCaps.version = 0x300; + TTYDRV_DC_DevCaps.horzSize = 0; /* FIXME: Screen width in mm */ + TTYDRV_DC_DevCaps.vertSize = 0; /* FIXME: Screen height in mm */ + TTYDRV_DC_DevCaps.horzRes = 640; /* FIXME: Screen width in pixel */ + TTYDRV_DC_DevCaps.vertRes = 480; /* FIXME: Screen height in pixel */ + TTYDRV_DC_DevCaps.bitsPixel = 1; /* FIXME: Bits per pixel */ + TTYDRV_DC_DevCaps.sizePalette = 0; /* FIXME: ??? */ /* Resolution will be adjusted during the font init */ - TTYDRV_GDI_DevCaps.logPixelsX = (int) (TTYDRV_GDI_DevCaps.horzRes * 25.4 / TTYDRV_GDI_DevCaps.horzSize); - TTYDRV_GDI_DevCaps.logPixelsY = (int) (TTYDRV_GDI_DevCaps.vertRes * 25.4 / TTYDRV_GDI_DevCaps.vertSize); + TTYDRV_DC_DevCaps.logPixelsX = (int) (TTYDRV_DC_DevCaps.horzRes * 25.4 / TTYDRV_DC_DevCaps.horzSize); + TTYDRV_DC_DevCaps.logPixelsY = (int) (TTYDRV_DC_DevCaps.vertRes * 25.4 / TTYDRV_DC_DevCaps.vertSize); - if( !COLOR_Init() ) return FALSE; + if(!TTYDRV_PALETTE_Initialize()) + return FALSE; - return DRIVER_RegisterDriver( "DISPLAY", &TTYDRV_GDI_Driver ); + return DRIVER_RegisterDriver( "DISPLAY", &TTYDRV_DC_Driver ); } /********************************************************************** * TTYDRV_GDI_Finalize */ -void TTDRV_GDI_Finalize() +void TTYDRV_GDI_Finalize(void) { + TTYDRV_PALETTE_Finalize(); } /********************************************************************** - * TTYDRV_GDI_CreateDC + * TTYDRV_DC_CreateDC */ -BOOL TTYDRV_GDI_CreateDC(DC *dc, LPCSTR driver, LPCSTR device, - LPCSTR output, const DEVMODE16 *initData) +BOOL TTYDRV_DC_CreateDC(DC *dc, LPCSTR driver, LPCSTR device, + LPCSTR output, const DEVMODE16 *initData) { FIXME(ttydrv, "(%p, %s, %s, %s, %p): semistub\n", dc, debugstr_a(driver), debugstr_a(device), @@ -155,16 +184,16 @@ BOOL TTYDRV_GDI_CreateDC(DC *dc, LPCSTR driver, LPCSTR device, return FALSE; } - dc->w.devCaps = &TTYDRV_GDI_DevCaps; + dc->w.devCaps = &TTYDRV_DC_DevCaps; return TRUE; } /********************************************************************** - * TTYDRV_GDI_DeleteDC + * TTYDRV_DC_DeleteDC */ -BOOL TTYDRV_GDI_DeleteDC(DC *dc) +BOOL TTYDRV_DC_DeleteDC(DC *dc) { FIXME(ttydrv, "(%p): semistub\n", dc); @@ -175,11 +204,10 @@ BOOL TTYDRV_GDI_DeleteDC(DC *dc) } /********************************************************************** - * TTYDRV_GDI_Escape + * TTYDRV_DC_Escape */ -INT TTYDRV_GDI_Escape(DC *dc, INT nEscape, INT cbInput, - SEGPTR lpInData, SEGPTR lpOutData) +INT TTYDRV_DC_Escape(DC *dc, INT nEscape, INT cbInput, + SEGPTR lpInData, SEGPTR lpOutData) { return 0; } - diff --git a/graphics/ttydrv/palette.c b/graphics/ttydrv/palette.c new file mode 100644 index 0000000000000000000000000000000000000000..55cd2fa6bb6359a4d1ba80bf9dcec9aec6c35033 --- /dev/null +++ b/graphics/ttydrv/palette.c @@ -0,0 +1,41 @@ +/* + * TTY palette driver + * + * Copyright 1999 Patrik Stridvall + */ + +#include "palette.h" +#include "ttydrv.h" + +/********************************************************************** + * TTYDRV_PALETTE_Initialize + */ +BOOL TTYDRV_PALETTE_Initialize(void) +{ + return TRUE; +} + +/********************************************************************** + * TTYDRV_PALETTE_Finalize + * + */ +void TTYDRV_PALETTE_Finalize(void) +{ +} + +/*********************************************************************** + * TTYDRV_PALETTE_SetMapping + */ +int TTYDRV_PALETTE_SetMapping( + PALETTEOBJ *palPtr, UINT uStart, UINT uNum, BOOL mapOnly) +{ + return 0; +} + +/*********************************************************************** + * TTYDRV_PALETTE_UpdateMapping + */ +int TTYDRV_PALETTE_UpdateMapping(PALETTEOBJ *palPtr) +{ + return 0; +} diff --git a/graphics/win16drv/init.c b/graphics/win16drv/init.c index d8ae969be6d0c0e7b0886d7b7993a37cde83a057..f8f9b7e70e5b090a316ce7ff7af3217a2d063767 100644 --- a/graphics/win16drv/init.c +++ b/graphics/win16drv/init.c @@ -49,6 +49,8 @@ static const DC_FUNCTIONS WIN16DRV_Funcs = NULL, /* pCreateBitmap */ WIN16DRV_CreateDC, /* pCreateDC */ NULL, /* pDeleteDC */ + NULL, /* pCreateDIBSection */ + NULL, /* pCreateDIBSection16 */ NULL, /* pDeleteObject */ WIN16DRV_Ellipse, /* pEllipse */ WIN16DRV_EnumDeviceFonts, /* pEnumDeviceFonts */ diff --git a/graphics/wing.c b/graphics/wing.c index 2eac6066e8adda6908a9e86167aa90d9ec09f4d2..fd30439798631ea46ad1acd549b18160b6323d0d 100644 --- a/graphics/wing.c +++ b/graphics/wing.c @@ -6,28 +6,19 @@ #include "config.h" -#include "ts_xlib.h" -#ifdef HAVE_LIBXXSHM -#include <sys/types.h> -#include <sys/ipc.h> -#ifndef __EMX__ -#include <sys/shm.h> -#endif /* !defined(__EMX__) */ -#include "ts_xshm.h" -#endif /* defined(HAVE_LIBXXSHM) */ +#ifndef X_DISPLAY_MISSING #include "x11drv.h" +#endif /* !defined(X_DISPLAY_MISSING) */ #include "wine/winuser16.h" #include "bitmap.h" -#include "palette.h" -#include "dc.h" #include "debug.h" -#include "gdi.h" -#include "heap.h" -#include "selectors.h" +#include "ldt.h" #include "monitor.h" +#include "palette.h" #include "windef.h" -#include "xmalloc.h" +#include "wine/winuser16.h" + typedef enum WING_DITHER_TYPE { @@ -105,7 +96,11 @@ SEGPTR WINAPI WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi) if (bmpi) FIXME(wing, ": Todo - implement setting BITMAPINFO\n"); - return PTR_SEG_OFF_TO_SEGPTR(bmp->dib->selector, 0); +#ifndef X_DISPLAY_MISSING + return PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0); +#else /* !defined(X_DISPLAY_MISSING) */ + return NULL; +#endif /* !defined(X_DISPLAY_MISSING) */ } /*********************************************************************** diff --git a/graphics/x11drv/Makefile.in b/graphics/x11drv/Makefile.in index 0d1a1fa5f95edb9441e3804c83de92b8898fdd4d..679ad08c6252e62ff9c1edd55320e1f0e3fb6401 100644 --- a/graphics/x11drv/Makefile.in +++ b/graphics/x11drv/Makefile.in @@ -15,6 +15,7 @@ C_SRCS = \ init.c \ objects.c \ oembitmap.c \ + palette.c \ pen.c \ text.c \ xfont.c diff --git a/graphics/x11drv/bitblt.c b/graphics/x11drv/bitblt.c index 4eb220ef2c421dad461a21304d31ad244022ca53..d15abc54670d9f7f67ed014d3feefe786edef4cf 100644 --- a/graphics/x11drv/bitblt.c +++ b/graphics/x11drv/bitblt.c @@ -596,11 +596,11 @@ static void BITBLT_GetRow( XImage *image, int *pdata, INT row, pdata += swap ? start+width-1 : start; if (image->depth == depthDst) /* color -> color */ { - if (COLOR_PixelToPalette && (depthDst != 1)) + if (X11DRV_PALETTE_XPixelToPalette && (depthDst != 1)) if (swap) for (i = 0; i < width; i++) - *pdata-- = COLOR_PixelToPalette[XGetPixel( image, i, row )]; + *pdata-- = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )]; else for (i = 0; i < width; i++) - *pdata++ = COLOR_PixelToPalette[XGetPixel( image, i, row )]; + *pdata++ = X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, i, row )]; else if (swap) for (i = 0; i < width; i++) *pdata-- = XGetPixel( image, i, row ); @@ -611,10 +611,10 @@ static void BITBLT_GetRow( XImage *image, int *pdata, INT row, { if (image->depth == 1) /* monochrome -> color */ { - if (COLOR_PixelToPalette) + if (X11DRV_PALETTE_XPixelToPalette) { - fg = COLOR_PixelToPalette[fg]; - bg = COLOR_PixelToPalette[bg]; + fg = X11DRV_PALETTE_XPixelToPalette[fg]; + bg = X11DRV_PALETTE_XPixelToPalette[bg]; } if (swap) for (i = 0; i < width; i++) *pdata-- = XGetPixel( image, i, row ) ? bg : fg; @@ -873,7 +873,7 @@ static void BITBLT_GetSrcArea( DC *dcSrc, DC *dcDst, Pixmap pixmap, GC gc, if (dcSrc->w.bitsPerPixel == dcDst->w.bitsPerPixel) { - if (!COLOR_PixelToPalette || + if (!X11DRV_PALETTE_XPixelToPalette || (dcDst->w.bitsPerPixel == 1)) /* monochrome -> monochrome */ { XCopyArea( display, physDevSrc->drawable, pixmap, gc, @@ -897,7 +897,7 @@ static void BITBLT_GetSrcArea( DC *dcSrc, DC *dcDst, Pixmap pixmap, GC gc, for (y = 0; y < height; y++) for (x = 0; x < width; x++) XPutPixel(imageSrc, x, y, - COLOR_PixelToPalette[XGetPixel(imageSrc, x, y)]); + X11DRV_PALETTE_XPixelToPalette[XGetPixel(imageSrc, x, y)]); XPutImage( display, pixmap, gc, imageSrc, 0, 0, 0, 0, width, height ); XDestroyImage( imageSrc ); @@ -907,12 +907,12 @@ static void BITBLT_GetSrcArea( DC *dcSrc, DC *dcDst, Pixmap pixmap, GC gc, { if (dcSrc->w.bitsPerPixel == 1) /* monochrome -> color */ { - if (COLOR_PixelToPalette) + if (X11DRV_PALETTE_XPixelToPalette) { XSetBackground( display, gc, - COLOR_PixelToPalette[physDevDst->textPixel] ); + X11DRV_PALETTE_XPixelToPalette[physDevDst->textPixel] ); XSetForeground( display, gc, - COLOR_PixelToPalette[physDevDst->backgroundPixel]); + X11DRV_PALETTE_XPixelToPalette[physDevDst->backgroundPixel]); } else { @@ -955,8 +955,8 @@ static void BITBLT_GetDstArea(DC *dc, Pixmap pixmap, GC gc, RECT *visRectDst) INT height = visRectDst->bottom - visRectDst->top; X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev; - if (!COLOR_PixelToPalette || (dc->w.bitsPerPixel == 1) || - (COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) ) + if (!X11DRV_PALETTE_XPixelToPalette || (dc->w.bitsPerPixel == 1) || + (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) ) { XCopyArea( display, physDev->drawable, pixmap, gc, visRectDst->left, visRectDst->top, width, height, 0, 0 ); @@ -981,7 +981,7 @@ static void BITBLT_GetDstArea(DC *dc, Pixmap pixmap, GC gc, RECT *visRectDst) for (y = 0; y < height; y++) for (x = 0; x < width; x++) XPutPixel( image, x, y, - COLOR_PixelToPalette[XGetPixel( image, x, y )]); + X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y )]); XPutImage( display, pixmap, gc, image, 0, 0, 0, 0, width, height ); XDestroyImage( image ); } @@ -1000,10 +1000,10 @@ static void BITBLT_PutDstArea(DC *dc, Pixmap pixmap, GC gc, RECT *visRectDst) INT height = visRectDst->bottom - visRectDst->top; X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev; - /* !COLOR_PaletteToPixel is _NOT_ enough */ + /* !X11DRV_PALETTE_PaletteToXPixel is _NOT_ enough */ - if (!COLOR_PaletteToPixel || (dc->w.bitsPerPixel == 1) || - (COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) ) + if (!X11DRV_PALETTE_PaletteToXPixel || (dc->w.bitsPerPixel == 1) || + (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL) ) { XCopyArea( display, pixmap, physDev->drawable, gc, 0, 0, width, height, visRectDst->left, visRectDst->top ); @@ -1017,7 +1017,7 @@ static void BITBLT_PutDstArea(DC *dc, Pixmap pixmap, GC gc, RECT *visRectDst) for (x = 0; x < width; x++) { XPutPixel( image, x, y, - COLOR_PaletteToPixel[XGetPixel( image, x, y )]); + X11DRV_PALETTE_PaletteToXPixel[XGetPixel( image, x, y )]); } XPutImage( display, physDev->drawable, gc, image, 0, 0, visRectDst->left, visRectDst->top, width, height ); @@ -1192,12 +1192,12 @@ static BOOL BITBLT_InternalStretchBlt( DC *dcDst, INT xDst, INT yDst, if (!fStretch) switch(rop) /* A few optimisations */ { case BLACKNESS: /* 0x00 */ - if ((dcDst->w.bitsPerPixel == 1) || !COLOR_PaletteToPixel) + if ((dcDst->w.bitsPerPixel == 1) || !X11DRV_PALETTE_PaletteToXPixel) XSetFunction( display, physDevDst->gc, GXclear ); else { XSetFunction( display, physDevDst->gc, GXcopy ); - XSetForeground( display, physDevDst->gc, COLOR_PaletteToPixel[0] ); + XSetForeground( display, physDevDst->gc, X11DRV_PALETTE_PaletteToXPixel[0] ); XSetFillStyle( display, physDevDst->gc, FillSolid ); } XFillRectangle( display, physDevDst->drawable, physDevDst->gc, @@ -1205,12 +1205,12 @@ static BOOL BITBLT_InternalStretchBlt( DC *dcDst, INT xDst, INT yDst, return TRUE; case DSTINVERT: /* 0x55 */ - if ((dcDst->w.bitsPerPixel == 1) || !COLOR_PaletteToPixel || + if ((dcDst->w.bitsPerPixel == 1) || !X11DRV_PALETTE_PaletteToXPixel || !Options.perfectGraphics) { XSetFunction( display, physDevDst->gc, GXinvert ); - if( COLOR_GetSystemPaletteFlags() & (COLOR_PRIVATE | COLOR_VIRTUAL) ) + if( X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_PRIVATE | X11DRV_PALETTE_VIRTUAL) ) XSetFunction( display, physDevDst->gc, GXinvert); else { @@ -1287,13 +1287,13 @@ static BOOL BITBLT_InternalStretchBlt( DC *dcDst, INT xDst, INT yDst, return TRUE; case WHITENESS: /* 0xff */ - if ((dcDst->w.bitsPerPixel == 1) || !COLOR_PaletteToPixel) + if ((dcDst->w.bitsPerPixel == 1) || !X11DRV_PALETTE_PaletteToXPixel) XSetFunction( display, physDevDst->gc, GXset ); else { XSetFunction( display, physDevDst->gc, GXcopy ); XSetForeground( display, physDevDst->gc, - COLOR_PaletteToPixel[COLOR_GetSystemPaletteSize() - 1]); + X11DRV_PALETTE_PaletteToXPixel[X11DRV_DevCaps.sizePalette - 1]); XSetFillStyle( display, physDevDst->gc, FillSolid ); } XFillRectangle( display, physDevDst->drawable, physDevDst->gc, @@ -1407,11 +1407,11 @@ BOOL X11DRV_PatBlt( DC *dc, INT left, INT top, struct StretchBlt_params params = { dc, left, top, width, height, NULL, 0, 0, 0, 0, rop }; BOOL result; - DIB_UpdateDIBSection( dc, FALSE ); + X11DRV_DIB_UpdateDIBSection( dc, FALSE ); EnterCriticalSection( &X11DRV_CritSection ); result = (BOOL)CALL_LARGE_STACK( BITBLT_DoStretchBlt, ¶ms ); LeaveCriticalSection( &X11DRV_CritSection ); - DIB_UpdateDIBSection( dc, TRUE ); + X11DRV_DIB_UpdateDIBSection( dc, TRUE ); return result; } @@ -1426,12 +1426,12 @@ BOOL X11DRV_BitBlt( DC *dcDst, INT xDst, INT yDst, struct StretchBlt_params params = { dcDst, xDst, yDst, width, height, dcSrc, xSrc, ySrc, width, height, rop}; BOOL result; - DIB_UpdateDIBSection( dcDst, FALSE ); - DIB_UpdateDIBSection( dcSrc, FALSE ); + X11DRV_DIB_UpdateDIBSection( dcDst, FALSE ); + X11DRV_DIB_UpdateDIBSection( dcSrc, FALSE ); EnterCriticalSection( &X11DRV_CritSection ); result = (BOOL)CALL_LARGE_STACK( BITBLT_DoStretchBlt, ¶ms ); LeaveCriticalSection( &X11DRV_CritSection ); - DIB_UpdateDIBSection( dcDst, TRUE ); + X11DRV_DIB_UpdateDIBSection( dcDst, TRUE ); return result; } @@ -1448,12 +1448,12 @@ BOOL X11DRV_StretchBlt( DC *dcDst, INT xDst, INT yDst, dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop }; BOOL result; - DIB_UpdateDIBSection( dcDst, FALSE ); - DIB_UpdateDIBSection( dcSrc, FALSE ); + X11DRV_DIB_UpdateDIBSection( dcDst, FALSE ); + X11DRV_DIB_UpdateDIBSection( dcSrc, FALSE ); EnterCriticalSection( &X11DRV_CritSection ); result = (BOOL)CALL_LARGE_STACK( BITBLT_DoStretchBlt, ¶ms ); LeaveCriticalSection( &X11DRV_CritSection ); - DIB_UpdateDIBSection( dcDst, TRUE ); + X11DRV_DIB_UpdateDIBSection( dcDst, TRUE ); return result; } diff --git a/graphics/x11drv/brush.c b/graphics/x11drv/brush.c index a28104cb795064ee872ae676db68127004b47d05..cb564d76d68f1ce268a10be0435c4ac32c8cc639 100644 --- a/graphics/x11drv/brush.c +++ b/graphics/x11drv/brush.c @@ -88,7 +88,7 @@ static const int EGAmapping[TOTAL_LEVELS] = }; #define PIXEL_VALUE(r,g,b) \ - COLOR_mapEGAPixel[EGAmapping[((r)*PRIMARY_LEVELS+(g))*PRIMARY_LEVELS+(b)]] + X11DRV_PALETTE_mapEGAPixel[EGAmapping[((r)*PRIMARY_LEVELS+(g))*PRIMARY_LEVELS+(b)]] /* X image for building dithered pixmap */ static XImage *ditherImage = NULL; @@ -163,7 +163,7 @@ static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color ) else { /* Solid brush */ - physDev->brush.pixel = COLOR_ToPhysical( dc, color ); + physDev->brush.pixel = X11DRV_PALETTE_ToPhysical( dc, color ); physDev->brush.fillStyle = FillSolid; } } @@ -258,7 +258,7 @@ HBRUSH X11DRV_BRUSH_SelectObject( DC * dc, HBRUSH hbrush, BRUSHOBJ * brush ) case BS_HATCHED: TRACE(gdi, "BS_HATCHED\n" ); - physDev->brush.pixel = COLOR_ToPhysical( dc, brush->logbrush.lbColor ); + physDev->brush.pixel = X11DRV_PALETTE_ToPhysical( dc, brush->logbrush.lbColor ); physDev->brush.pixmap = TSXCreateBitmapFromData( display, X11DRV_GetXRootWindow(), HatchBrushes[brush->logbrush.lbHatch], 8, 8 ); physDev->brush.fillStyle = FillStippled; diff --git a/graphics/x11drv/dib.c b/graphics/x11drv/dib.c index 53d72d9dbbe6e4fefd647656125211e8ae877bd6..140c4e0fc03639a4d05951d3425bbcd4be308afa 100644 --- a/graphics/x11drv/dib.c +++ b/graphics/x11drv/dib.c @@ -18,7 +18,9 @@ #include "dc.h" #include "color.h" #include "callback.h" -#include "xmalloc.h" +#include "selectors.h" +#include "global.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 }; @@ -111,7 +113,7 @@ int *X11DRV_DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth, rgb->rgbBlue > 255*3/2); else for (i = 0; i < colors; i++, rgb++) - colorMapping[i] = COLOR_ToPhysical( dc, RGB(rgb->rgbRed, + colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, RGB(rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue)); } @@ -125,7 +127,7 @@ int *X11DRV_DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth, rgb->rgbtBlue > 255*3/2); else for (i = 0; i < colors; i++, rgb++) - colorMapping[i] = COLOR_ToPhysical( dc, RGB(rgb->rgbtRed, + colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, RGB(rgb->rgbtRed, rgb->rgbtGreen, rgb->rgbtBlue)); } @@ -133,7 +135,7 @@ int *X11DRV_DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth, else /* DIB_PAL_COLORS */ { for (i = 0; i < colors; i++, colorPtr++) - colorMapping[i] = COLOR_ToPhysical( dc, PALETTEINDEX(*colorPtr) ); + colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, PALETTEINDEX(*colorPtr) ); } *nColors = colors; @@ -705,7 +707,7 @@ static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits, g = (BYTE) ((val & 0x03e0) >> 2); b = (BYTE) ((val & 0x001f) << 3); XPutPixel( bmpImage, x, h, - COLOR_ToPhysical(dc, RGB(r,g,b)) ); + X11DRV_PALETTE_ToPhysical(dc, RGB(r,g,b)) ); } ptr = (LPWORD) (srcbits += linebytes) + left; } @@ -718,7 +720,7 @@ static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits, g = (BYTE) ((val & 0x03e0) >> 2); b = (BYTE) ((val & 0x001f) << 3); XPutPixel( bmpImage, x, h, - COLOR_ToPhysical(dc, RGB(r,g,b)) ); + X11DRV_PALETTE_ToPhysical(dc, RGB(r,g,b)) ); } ptr = (LPWORD) (srcbits += linebytes) + left; } @@ -751,7 +753,7 @@ static void X11DRV_DIB_GetImageBits_16( int lines, BYTE *srcbits, { for (x = left; x < dstwidth; x++, ptr++) { - COLORREF pixel = COLOR_ToLogical( XGetPixel( bmpImage, x, h ) ); + COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) ); r = (BYTE) GetRValue(pixel); g = (BYTE) GetGValue(pixel); b = (BYTE) GetBValue(pixel); @@ -765,7 +767,7 @@ static void X11DRV_DIB_GetImageBits_16( int lines, BYTE *srcbits, { for (x = left; x < dstwidth; x++, ptr++) { - COLORREF pixel = COLOR_ToLogical( XGetPixel( bmpImage, x, h ) ); + COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) ); r = (BYTE) GetRValue(pixel); g = (BYTE) GetGValue(pixel); b = (BYTE) GetBValue(pixel); @@ -803,7 +805,7 @@ static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits, for (h = lines - 1; h >= 0; h--) { for (x = left; x < dstwidth; x++, bits += 3) { XPutPixel( bmpImage, x, h, - COLOR_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); + X11DRV_PALETTE_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); } bits = (srcbits += linebytes) + left * 3; } @@ -812,7 +814,7 @@ static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits, for (h = 0; h < lines; h++) { for (x = left; x < dstwidth; x++, bits += 3) { XPutPixel( bmpImage, x, h, - COLOR_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); + X11DRV_PALETTE_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); } bits = (srcbits += linebytes) + left * 3; } @@ -843,7 +845,7 @@ static void X11DRV_DIB_GetImageBits_24( int lines, BYTE *srcbits, { for (x = left; x < dstwidth; x++, bits += 3) { - COLORREF pixel = COLOR_ToLogical( XGetPixel( bmpImage, x, h ) ); + COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) ); bits[0] = GetRValue(pixel); bits[1] = GetGValue(pixel); bits[2] = GetBValue(pixel); @@ -856,7 +858,7 @@ static void X11DRV_DIB_GetImageBits_24( int lines, BYTE *srcbits, { for (x = left; x < dstwidth; x++, bits += 3) { - COLORREF pixel = COLOR_ToLogical( XGetPixel( bmpImage, x, h ) ); + COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) ); bits[0] = GetRValue(pixel); bits[1] = GetGValue(pixel); bits[2] = GetBValue(pixel); @@ -889,7 +891,7 @@ static void X11DRV_DIB_SetImageBits_32( int lines, const BYTE *srcbits, for (h = lines - 1; h >= 0; h--) { for (x = left; x < dstwidth; x++, bits += 4) { XPutPixel( bmpImage, x, h, - COLOR_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); + X11DRV_PALETTE_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); } bits = (srcbits += linebytes) + left * 4; } @@ -898,7 +900,7 @@ static void X11DRV_DIB_SetImageBits_32( int lines, const BYTE *srcbits, for (h = 0; h < lines; h++) { for (x = left; x < dstwidth; x++, bits += 4) { XPutPixel( bmpImage, x, h, - COLOR_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); + X11DRV_PALETTE_ToPhysical(dc, RGB(bits[2],bits[1],bits[0]))); } bits = (srcbits += linebytes) + left * 4; } @@ -929,7 +931,7 @@ static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *srcbits, { for (x = left; x < dstwidth; x++, bits += 4) { - COLORREF pixel = COLOR_ToLogical( XGetPixel( bmpImage, x, h ) ); + COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) ); bits[0] = GetRValue(pixel); bits[1] = GetGValue(pixel); bits[2] = GetBValue(pixel); @@ -942,7 +944,7 @@ static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *srcbits, { for (x = left; x < dstwidth; x++, bits += 4) { - COLORREF pixel = COLOR_ToLogical( XGetPixel( bmpImage, x, h ) ); + COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) ); bits[0] = GetRValue(pixel); bits[1] = GetGValue(pixel); bits[2] = GetBValue(pixel); @@ -961,7 +963,7 @@ static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *srcbits, * Helper function for SetDIBits() and SetDIBitsToDevice(). * The Xlib critical section must be entered before calling this function. */ -int X11DRV_DIB_SetImageBits( const DIB_SETIMAGEBITS_DESCR *descr ) +int X11DRV_DIB_SetImageBits( const X11DRV_DIB_SETIMAGEBITS_DESCR *descr ) { int lines = descr->lines >= 0 ? descr->lines : -descr->lines; XImage *bmpImage; @@ -1046,7 +1048,7 @@ int X11DRV_DIB_SetImageBits( const DIB_SETIMAGEBITS_DESCR *descr ) * Transfer the bits from an X image. * The Xlib critical section must be entered before calling this function. */ -int X11DRV_DIB_GetImageBits( const DIB_SETIMAGEBITS_DESCR *descr ) +int X11DRV_DIB_GetImageBits( const X11DRV_DIB_SETIMAGEBITS_DESCR *descr ) { int lines = descr->lines >= 0 ? descr->lines : -descr->lines; XImage *bmpImage; @@ -1130,7 +1132,7 @@ INT X11DRV_SetDIBitsToDevice( DC *dc, INT xDest, INT yDest, DWORD cx, UINT startscan, UINT lines, LPCVOID bits, const BITMAPINFO *info, UINT coloruse ) { - DIB_SETIMAGEBITS_DESCR descr; + X11DRV_DIB_SETIMAGEBITS_DESCR descr; DWORD width, oldcy = cy; INT result; int height, tmpheight; @@ -1188,4 +1190,865 @@ INT X11DRV_SetDIBitsToDevice( DC *dc, INT xDest, INT yDest, DWORD cx, return result; } +/*********************************************************************** + * X11DRV_DIB_SetDIBits + */ +INT X11DRV_DIB_SetDIBits( + BITMAPOBJ *bmp, DC *dc, UINT startscan, + UINT lines, LPCVOID bits, const BITMAPINFO *info, + UINT coloruse, HBITMAP hbitmap) +{ + X11DRV_DIB_SETIMAGEBITS_DESCR descr; + X11DRV_PHYSBITMAP *pbitmap; + int height, tmpheight; + INT result; + + descr.dc = dc; + + if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &height, + &descr.infoBpp, &descr.compression ) == -1) + return 0; + + tmpheight = height; + if (height < 0) height = -height; + if (!lines || (startscan >= height)) + return 0; + + if (startscan + lines > height) lines = height - startscan; + + if (descr.infoBpp <= 8) + { + descr.colorMap = X11DRV_DIB_BuildColorMap( descr.dc, coloruse, + bmp->bitmap.bmBitsPixel, + info, &descr.nColorMap ); + if (!descr.colorMap) + { + return 0; + } + } else + descr.colorMap = 0; + + /* HACK for now */ + if(!bmp->DDBitmap) + X11DRV_CreateBitmap(hbitmap); + + pbitmap = bmp->DDBitmap->physBitmap; + + descr.bits = bits; + descr.image = NULL; + descr.lines = tmpheight >= 0 ? lines : -lines; + descr.depth = bmp->bitmap.bmBitsPixel; + descr.drawable = pbitmap->pixmap; + descr.gc = BITMAP_GC(bmp); + descr.xSrc = 0; + descr.ySrc = 0; + descr.xDest = 0; + descr.yDest = height - startscan - lines; + descr.width = bmp->bitmap.bmWidth; + descr.height = lines; + + EnterCriticalSection( &X11DRV_CritSection ); + result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr ); + LeaveCriticalSection( &X11DRV_CritSection ); + + if (descr.colorMap) HeapFree(GetProcessHeap(), 0, descr.colorMap); + + return result; +} + + +/********************************************************************* + * X11DRV_DIB_GetNearestIndex + * + * Helper for X11DRV_DIB_GetDIBits. + * Returns the nearest colour table index for a given RGB. + * Nearest is defined by minimizing the sum of the squares. + */ +static INT X11DRV_DIB_GetNearestIndex(BITMAPINFO *info, BYTE r, BYTE g, BYTE b) +{ + INT i, best = -1, diff, bestdiff = -1; + RGBQUAD *color; + + for(color = info->bmiColors, i = 0; i < (1 << info->bmiHeader.biBitCount); + color++, i++) { + diff = (r - color->rgbRed) * (r - color->rgbRed) + + (g - color->rgbGreen) * (g - color->rgbGreen) + + (b - color->rgbBlue) * (b - color->rgbBlue); + if(diff == 0) + return i; + if(best == -1 || diff < bestdiff) { + best = i; + bestdiff = diff; + } + } + return best; +} + +/*********************************************************************** + * X11DRV_DIB_GetDIBits + */ +INT X11DRV_DIB_GetDIBits( + BITMAPOBJ *bmp, DC *dc, UINT startscan, + UINT lines, LPVOID bits, BITMAPINFO *info, + UINT coloruse, HBITMAP hbitmap) +{ + XImage * bmpImage; + int x, y; + PALETTEENTRY * palEntry; + PALETTEOBJ * palette; + BYTE *bbits = (BYTE*)bits, *linestart; + int dstwidth, yend, xend = bmp->bitmap.bmWidth; + + TRACE(bitmap, "%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n", + lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight, + (int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight, + startscan ); + + if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC ))) + return 0; + + /* adjust number of scanlines to copy */ + + if( lines > info->bmiHeader.biHeight ) + lines = info->bmiHeader.biHeight; + + yend = startscan + lines; + if( startscan >= bmp->bitmap.bmHeight ) + { + return FALSE; + } + if( yend > bmp->bitmap.bmHeight ) yend = bmp->bitmap.bmHeight; + + /* adjust scanline width */ + + if(bmp->bitmap.bmWidth > info->bmiHeader.biWidth) + xend = info->bmiHeader.biWidth; + + /* HACK for now */ + if(!bmp->DDBitmap) + X11DRV_CreateBitmap(hbitmap); + + dstwidth = DIB_GetDIBWidthBytes( info->bmiHeader.biWidth, + info->bmiHeader.biBitCount ); + + EnterCriticalSection( &X11DRV_CritSection ); + bmpImage = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp ); + + linestart = bbits; + switch( info->bmiHeader.biBitCount ) { + + case 1: /* 1 bit DIB */ + { + unsigned long white = (1 << bmp->bitmap.bmBitsPixel) - 1; + + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + if (!(x&7)) *bbits = 0; + *bbits |= (XGetPixel( bmpImage, x, y) >= white) + << (7 - (x&7)); + if ((x&7)==7) bbits++; + } + bbits = (linestart += dstwidth); + } + } + break; + + + case 4: /* 4 bit DIB */ + switch(bmp->bitmap.bmBitsPixel) { + + case 1: /* 1/4 bit bmp -> 4 bit DIB */ + case 4: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + if (!(x&1)) *bbits = 0; + *bbits |= XGetPixel( bmpImage, x, y)<<(4*(1-(x&1))); + if ((x&1)==1) bbits++; + } + bbits = (linestart += dstwidth); + } + break; + + case 8: /* 8 bit bmp -> 4 bit DIB */ + palEntry = palette->logpalette.palPalEntry; + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel = XGetPixel( bmpImage, x, y ); + if (!(x&1)) *bbits = 0; + *bbits |= ( X11DRV_DIB_GetNearestIndex(info, + palEntry[pixel].peRed, + palEntry[pixel].peGreen, + palEntry[pixel].peBlue ) + << (4*(1-(x&1))) ); + if ((x&1)==1) bbits++; + } + bbits = (linestart += dstwidth); + } + break; + + case 15: /* 15/16 bit bmp -> 4 bit DIB */ + case 16: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel = XGetPixel( bmpImage, x, y ); + if (!(x&1)) *bbits = 0; + *bbits |= ( X11DRV_DIB_GetNearestIndex(info, + ((pixel << 3) & 0xf8) | + ((pixel >> 2) & 0x7), + ((pixel >> 2) & 0xf8) | + ((pixel >> 7) & 0x7), + ((pixel >> 7) & 0xf8) | + ((pixel >> 12) & 0x7) ) + << (4*(1-(x&1))) ); + if ((x&1)==1) bbits++; + } + bbits = (linestart += dstwidth); + } + break; + + case 24: /* 24/32 bit bmp -> 4 bit DIB */ + case 32: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel = XGetPixel( bmpImage, x, y ); + if (!(x&1)) *bbits = 0; + *bbits |= ( X11DRV_DIB_GetNearestIndex( info, + (pixel >> 16) & 0xff, + (pixel >> 8) & 0xff, + pixel & 0xff ) + << (4*(1-(x&1))) ); + if ((x&1)==1) bbits++; + } + bbits = (linestart += dstwidth); + } + break; + + default: /* ? bit bmp -> 4 bit DIB */ + FIXME(bitmap, "4 bit DIB %d bit bitmap\n", + bmp->bitmap.bmBitsPixel); + break; + } + break; + + + case 8: /* 8 bit DIB */ + switch(bmp->bitmap.bmBitsPixel) { + + case 1: /* 1/4/8 bit bmp -> 8 bit DIB */ + case 4: + case 8: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) + *bbits++ = XGetPixel( bmpImage, x, y ); + bbits = (linestart += dstwidth); + } + break; + + case 15: /* 15/16 bit bmp -> 8 bit DIB */ + case 16: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel = XGetPixel( bmpImage, x, y ); + *bbits++ = X11DRV_DIB_GetNearestIndex( info, + ((pixel << 3) & 0xf8) | + ((pixel >> 2) & 0x7), + ((pixel >> 2) & 0xf8) | + ((pixel >> 7) & 0x7), + ((pixel >> 7) & 0xf8) | + ((pixel >> 12) & 0x7) ); + } + bbits = (linestart += dstwidth); + } + break; + + case 24: /* 24/32 bit bmp -> 8 bit DIB */ + case 32: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel = XGetPixel( bmpImage, x, y ); + *bbits++ = X11DRV_DIB_GetNearestIndex( info, + (pixel >> 16) & 0xff, + (pixel >> 8) & 0xff, + pixel & 0xff ); + } + bbits = (linestart += dstwidth); + } + break; + + default: /* ? bit bmp -> 8 bit DIB */ + FIXME(bitmap, "8 bit DIB %d bit bitmap\n", + bmp->bitmap.bmBitsPixel); + break; + } + break; + + + case 15: /* 15/16 bit DIB */ + case 16: + switch(bmp->bitmap.bmBitsPixel) { + + case 15: /* 15/16 bit bmp -> 16 bit DIB */ + case 16: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = pixel & 0xff; + *bbits++ = (pixel >> 8) & 0xff; + } + bbits = (linestart += dstwidth); + } + break; + + case 24: /* 24/32 bit bmp -> 16 bit DIB */ + case 32: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = ((pixel >> 6) & 0xe0) | + ((pixel >> 3) & 0x1f); + *bbits++ = ((pixel >> 17) & 0x7c) | + ((pixel >> 14) & 0x3); + } + bbits = (linestart += dstwidth); + } + break; + + case 1: /* 1/4/8 bit bmp -> 16 bit DIB */ + case 4: + case 8: + palEntry = palette->logpalette.palPalEntry; + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = ((palEntry[pixel].peBlue >> 3) & 0x1f) | + ((palEntry[pixel].peGreen << 2) & 0xe0); + *bbits++ = ((palEntry[pixel].peGreen >> 6) & 0x3) | + ((palEntry[pixel].peRed >> 1) & 0x7c); + } + bbits = (linestart += dstwidth); + } + break; + + default: /* ? bit bmp -> 16 bit DIB */ + FIXME(bitmap, "15/16 bit DIB %d bit bitmap\n", + bmp->bitmap.bmBitsPixel); + break; + } + break; + + + case 24: /* 24 bit DIB */ + switch(bmp->bitmap.bmBitsPixel) { + + case 24: /* 24/32 bit bmp -> 24 bit DIB */ + case 32: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = (pixel >>16) & 0xff; + *bbits++ = (pixel >> 8) & 0xff; + *bbits++ = pixel & 0xff; + } + bbits = (linestart += dstwidth); + } + break; + + case 15: /* 15/16 bit bmp -> 24 bit DIB */ + case 16: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = ((pixel >> 7) & 0xf8) | + ((pixel >> 12) & 0x7); + *bbits++ = ((pixel >> 2) & 0xf8) | + ((pixel >> 7) & 0x7); + *bbits++ = ((pixel << 3) & 0xf8) | + ((pixel >> 2) & 0x7); + } + bbits = (linestart += dstwidth); + } + break; + + case 1: /* 1/4/8 bit bmp -> 24 bit DIB */ + case 4: + case 8: + palEntry = palette->logpalette.palPalEntry; + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = palEntry[pixel].peBlue; + *bbits++ = palEntry[pixel].peGreen; + *bbits++ = palEntry[pixel].peRed; + } + bbits = (linestart += dstwidth); + } + break; + + default: /* ? bit bmp -> 24 bit DIB */ + FIXME(bitmap, "24 bit DIB %d bit bitmap\n", + bmp->bitmap.bmBitsPixel); + break; + } + break; + + + case 32: /* 32 bit DIB */ + switch(bmp->bitmap.bmBitsPixel) { + + case 24: /* 24/32 bit bmp -> 32 bit DIB */ + case 32: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = (pixel >>16) & 0xff; + *bbits++ = (pixel >> 8) & 0xff; + *bbits++ = pixel & 0xff; + *bbits++ = 0; + } + bbits = (linestart += dstwidth); + } + break; + + case 15: /* 15/16 bit bmp -> 32 bit DIB */ + case 16: + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = ((pixel >> 7) & 0xf8) | + ((pixel >> 12) & 0x7); + *bbits++ = ((pixel >> 2) & 0xf8) | + ((pixel >> 7) & 0x7); + *bbits++ = ((pixel << 3) & 0xf8) | + ((pixel >> 2) & 0x7); + *bbits++ = 0; + } + bbits = (linestart += dstwidth); + } + break; + + case 1: /* 1/4/8 bit bmp -> 32 bit DIB */ + case 4: + case 8: + palEntry = palette->logpalette.palPalEntry; + for( y = yend - 1; (int)y >= (int)startscan; y-- ) { + for( x = 0; x < xend; x++ ) { + unsigned long pixel=XGetPixel( bmpImage, x, y); + *bbits++ = palEntry[pixel].peBlue; + *bbits++ = palEntry[pixel].peGreen; + *bbits++ = palEntry[pixel].peRed; + *bbits++ = 0; + } + bbits = (linestart += dstwidth); + } + break; + + default: /* ? bit bmp -> 32 bit DIB */ + FIXME(bitmap, "32 bit DIB %d bit bitmap\n", + bmp->bitmap.bmBitsPixel); + break; + } + break; + + + default: /* ? bit DIB */ + FIXME(bitmap,"Unsupported DIB depth %d\n", + info->bmiHeader.biBitCount); + break; + } + + XDestroyImage( bmpImage ); + LeaveCriticalSection( &X11DRV_CritSection ); + + if(info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */ + info->bmiHeader.biSizeImage = info->bmiHeader.biHeight * + DIB_GetDIBWidthBytes( info->bmiHeader.biWidth, + info->bmiHeader.biBitCount ); + + if(bbits - (BYTE *)bits > info->bmiHeader.biSizeImage) + ERR(bitmap, "Buffer overrun. Please investigate.\n"); + + info->bmiHeader.biCompression = 0; + + GDI_HEAP_UNLOCK( dc->w.hPalette ); + + return lines; +} + +/*********************************************************************** + * DIB_DoProtectDIBSection + */ +static void X11DRV_DIB_DoProtectDIBSection( BITMAPOBJ *bmp, DWORD new_prot ) +{ + DIBSECTION *dib = bmp->dib; + INT effHeight = dib->dsBm.bmHeight >= 0? dib->dsBm.bmHeight + : -dib->dsBm.bmHeight; + INT totalSize = dib->dsBmih.biSizeImage? dib->dsBmih.biSizeImage + : dib->dsBm.bmWidthBytes * effHeight; + DWORD old_prot; + + VirtualProtect(dib->dsBm.bmBits, totalSize, new_prot, &old_prot); + TRACE(bitmap, "Changed protection from %ld to %ld\n", + old_prot, new_prot); +} + +/*********************************************************************** + * X11DRV_DIB_DoUpdateDIBSection + */ +static void X11DRV_DIB_DoUpdateDIBSection(BITMAPOBJ *bmp, BOOL toDIB) +{ + X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib; + X11DRV_DIB_SETIMAGEBITS_DESCR descr; + + if (DIB_GetBitmapInfo( &dib->dibSection.dsBmih, &descr.infoWidth, &descr.lines, + &descr.infoBpp, &descr.compression ) == -1) + return; + + descr.dc = NULL; + descr.image = dib->image; + descr.colorMap = dib->colorMap; + descr.nColorMap = dib->nColorMap; + descr.bits = dib->dibSection.dsBm.bmBits; + descr.depth = bmp->bitmap.bmBitsPixel; + + /* Hack for now */ + descr.drawable = ((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap; + descr.gc = BITMAP_GC(bmp); + descr.xSrc = 0; + descr.ySrc = 0; + descr.xDest = 0; + descr.yDest = 0; + descr.width = bmp->bitmap.bmWidth; + descr.height = bmp->bitmap.bmHeight; + + if (toDIB) + { + TRACE(bitmap, "Copying from Pixmap to DIB bits\n"); + EnterCriticalSection( &X11DRV_CritSection ); + CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr ); + LeaveCriticalSection( &X11DRV_CritSection ); + } + else + { + TRACE(bitmap, "Copying from DIB bits to Pixmap\n"); + EnterCriticalSection( &X11DRV_CritSection ); + CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr ); + LeaveCriticalSection( &X11DRV_CritSection ); + } +} + +/*********************************************************************** + * X11DRV_DIB_FaultHandler + */ +static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr ) +{ + BOOL handled = FALSE; + BITMAPOBJ *bmp; + + bmp = (BITMAPOBJ *)GDI_GetObjPtr( (HBITMAP)res, BITMAP_MAGIC ); + if (!bmp) return FALSE; + + if (bmp->dib) + switch (((X11DRV_DIBSECTION *) bmp->dib)->status) + { + case X11DRV_DIB_GdiMod: + TRACE( bitmap, "called in status DIB_GdiMod\n" ); + X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE ); + X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE ); + X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY ); + ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync; + handled = TRUE; + break; + + case X11DRV_DIB_InSync: + TRACE( bitmap, "called in status X11DRV_DIB_InSync\n" ); + X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE ); + ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_AppMod; + handled = TRUE; + break; + + case X11DRV_DIB_AppMod: + FIXME( bitmap, "called in status X11DRV_DIB_AppMod: " + "this can't happen!\n" ); + break; + + case X11DRV_DIB_NoHandler: + FIXME( bitmap, "called in status DIB_NoHandler: " + "this can't happen!\n" ); + break; + } + + GDI_HEAP_UNLOCK( (HBITMAP)res ); + return handled; +} + +/*********************************************************************** + * X11DRV_DIB_UpdateDIBSection + */ +void X11DRV_DIB_UpdateDIBSection(DC *dc, BOOL toDIB) +{ + BITMAPOBJ *bmp; + + /* Ensure this is a Compatible DC that has a DIB section selected */ + + if (!dc) return; + if (!(dc->w.flags & DC_MEMORY)) return; + + bmp = (BITMAPOBJ *)GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC ); + if (!bmp) return; + + if (!bmp->dib) + { + GDI_HEAP_UNLOCK(dc->w.hBitmap); + return; + } + + if (!toDIB) + { + /* Prepare for access to the DIB by GDI functions */ + + switch (((X11DRV_DIBSECTION *) bmp->dib)->status) + { + default: + case X11DRV_DIB_NoHandler: + X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE ); + break; + + case X11DRV_DIB_GdiMod: + TRACE( bitmap, "fromDIB called in status X11DRV_DIB_GdiMod\n" ); + /* nothing to do */ + break; + + case X11DRV_DIB_InSync: + TRACE( bitmap, "fromDIB called in status X11DRV_DIB_InSync\n" ); + /* nothing to do */ + break; + + case X11DRV_DIB_AppMod: + TRACE( bitmap, "fromDIB called in status X11DRV_DIB_AppMod\n" ); + X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE ); + X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY ); + ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync; + break; + } + } + else + { + /* Acknowledge write access to the DIB by GDI functions */ + + switch (((X11DRV_DIBSECTION *) bmp->dib)->status) + { + default: + case X11DRV_DIB_NoHandler: + X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE ); + break; + + case X11DRV_DIB_GdiMod: + TRACE( bitmap, " toDIB called in status X11DRV_DIB_GdiMod\n" ); + /* nothing to do */ + break; + + case X11DRV_DIB_InSync: + TRACE( bitmap, " toDIB called in status X11DRV_DIB_InSync\n" ); + X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS ); + ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_GdiMod; + break; + + case X11DRV_DIB_AppMod: + FIXME( bitmap, " toDIB called in status X11DRV_DIB_AppMod: " + "this can't happen!\n" ); + break; + } + } + + GDI_HEAP_UNLOCK(dc->w.hBitmap); +} + +/*********************************************************************** + * X11DRV_DIB_CreateDIBSection16 + */ +HBITMAP16 X11DRV_DIB_CreateDIBSection16( + DC *dc, BITMAPINFO *bmi, UINT16 usage, + SEGPTR *bits, HANDLE section, + DWORD offset) +{ + HBITMAP res = X11DRV_DIB_CreateDIBSection(dc, bmi, usage, NULL, + section, offset); + if ( res ) + { + BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC); + if ( bmp && bmp->dib ) + { + DIBSECTION *dib = bmp->dib; + INT height = dib->dsBm.bmHeight >= 0 ? + dib->dsBm.bmHeight : -dib->dsBm.bmHeight; + INT size = dib->dsBmih.biSizeImage ? + dib->dsBmih.biSizeImage : dib->dsBm.bmWidthBytes * height; + if ( dib->dsBm.bmBits ) + { + ((X11DRV_DIBSECTION *) bmp->dib)->selector = + SELECTOR_AllocBlock( dib->dsBm.bmBits, size, + SEGMENT_DATA, FALSE, FALSE ); + } + printf("ptr = %p, size =%d, selector = %04x, segptr = %ld\n", + dib->dsBm.bmBits, size, ((X11DRV_DIBSECTION *) bmp->dib)->selector, + PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0)); + } + GDI_HEAP_UNLOCK( res ); + + if ( bits ) + *bits = PTR_SEG_OFF_TO_SEGPTR( ((X11DRV_DIBSECTION *) bmp->dib)->selector, 0 ); + } + + return res; +} + + +/*********************************************************************** + * X11DRV_DIB_CreateDIBSection + */ +HBITMAP X11DRV_DIB_CreateDIBSection( + DC *dc, BITMAPINFO *bmi, UINT usage, + LPVOID *bits, HANDLE section, + DWORD offset) +{ + HBITMAP res = 0; + BITMAPOBJ *bmp = NULL; + X11DRV_DIBSECTION *dib = NULL; + int *colorMap = NULL; + int nColorMap; + + /* Fill BITMAP32 structure with DIB data */ + BITMAPINFOHEADER *bi = &bmi->bmiHeader; + INT effHeight, totalSize; + BITMAP bm; + + TRACE(bitmap, "format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n", + bi->biWidth, bi->biHeight, bi->biPlanes, bi->biBitCount, + bi->biSizeImage, bi->biClrUsed, usage == DIB_PAL_COLORS? "PAL" : "RGB"); + + bm.bmType = 0; + bm.bmWidth = bi->biWidth; + bm.bmHeight = bi->biHeight; + bm.bmWidthBytes = DIB_GetDIBWidthBytes(bm.bmWidth, bi->biBitCount); + bm.bmPlanes = bi->biPlanes; + bm.bmBitsPixel = bi->biBitCount; + bm.bmBits = NULL; + + /* Get storage location for DIB bits */ + effHeight = bm.bmHeight >= 0 ? bm.bmHeight : -bm.bmHeight; + totalSize = bi->biSizeImage? bi->biSizeImage : bm.bmWidthBytes * effHeight; + + if (section) + bm.bmBits = MapViewOfFile(section, FILE_MAP_ALL_ACCESS, + 0L, offset, totalSize); + else + bm.bmBits = VirtualAlloc(NULL, totalSize, + MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE); + + /* Create Color Map */ + if (bm.bmBits && bm.bmBitsPixel <= 8) + { + if(dc) + colorMap = X11DRV_DIB_BuildColorMap( dc, usage, bm.bmBitsPixel, + bmi, &nColorMap ); + } + + /* Allocate Memory for DIB and fill structure */ + if (bm.bmBits) + dib = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(X11DRV_DIBSECTION)); + if (dib) + { + dib->dibSection.dsBm = bm; + dib->dibSection.dsBmih = *bi; + /* FIXME: dib->dibSection.dsBitfields ??? */ + dib->dibSection.dshSection = section; + dib->dibSection.dsOffset = offset; + + dib->status = X11DRV_DIB_NoHandler; + dib->selector = 0; + + dib->nColorMap = nColorMap; + dib->colorMap = colorMap; + } + + /* Create Device Dependent Bitmap and add DIB pointer */ + if (dib) + { + res = CreateDIBitmap(dc->hSelf, bi, 0, NULL, bmi, usage); + if (res) + { + bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC); + if (bmp) + { + bmp->dib = (DIBSECTION *) dib; + /* HACK for now */ + if(!bmp->DDBitmap) + X11DRV_CreateBitmap(res); + } + } + } + + /* Create XImage */ + if (dib && bmp) + XCREATEIMAGE( dib->image, bm.bmWidth, effHeight, bmp->bitmap.bmBitsPixel ); + + /* Clean up in case of errors */ + if (!res || !bmp || !dib || !bm.bmBits || (bm.bmBitsPixel <= 8 && !colorMap)) + { + TRACE(bitmap, "got an error res=%08x, bmp=%p, dib=%p, bm.bmBits=%p\n", + res, bmp, dib, bm.bmBits); + if (bm.bmBits) + { + if (section) + UnmapViewOfFile(bm.bmBits), bm.bmBits = NULL; + else + VirtualFree(bm.bmBits, MEM_RELEASE, 0L), bm.bmBits = NULL; + } + + if (dib && dib->image) { XDestroyImage(dib->image); dib->image = NULL; } + if (colorMap) { HeapFree(GetProcessHeap(), 0, colorMap); colorMap = NULL; } + if (dib) { HeapFree(GetProcessHeap(), 0, dib); dib = NULL; } + if (res) { DeleteObject(res); res = 0; } + } + + /* Install fault handler, if possible */ + if (bm.bmBits) + { + if (VIRTUAL_SetFaultHandler(bm.bmBits, X11DRV_DIB_FaultHandler, (LPVOID)res)) + { + X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY ); + if (dib) dib->status = X11DRV_DIB_InSync; + } + } + + /* Return BITMAP handle and storage location */ + if (res) GDI_HEAP_UNLOCK(res); + if (bm.bmBits && bits) *bits = bm.bmBits; + return res; +} + +/*********************************************************************** + * X11DRV_DIB_DeleteDIBSection + */ +void X11DRV_DIB_DeleteDIBSection(BITMAPOBJ *bmp) +{ + X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib; + + if (dib->image) + XDestroyImage( dib->image ); + + if (dib->colorMap) + HeapFree(GetProcessHeap(), 0, dib->colorMap); + + if (dib->selector) + { + WORD count = (GET_SEL_LIMIT( dib->selector ) >> 16) + 1; + SELECTOR_FreeBlock( dib->selector, count ); + } +} + + #endif /* !defined(X_DISPLAY_MISSING) */ + + + diff --git a/graphics/x11drv/graphics.c b/graphics/x11drv/graphics.c index 531caf95112be700250a88da9882fc7f8edb0cf6..4c687ccfccb4b022f662b5e9fd08ed3fddae5512 100644 --- a/graphics/x11drv/graphics.c +++ b/graphics/x11drv/graphics.c @@ -96,10 +96,10 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors ) val.foreground = physDev->brush.pixel; val.background = physDev->backgroundPixel; } - if (fMapColors && COLOR_PixelToPalette) + if (fMapColors && X11DRV_PALETTE_XPixelToPalette) { - val.foreground = COLOR_PixelToPalette[val.foreground]; - val.background = COLOR_PixelToPalette[val.background]; + val.foreground = X11DRV_PALETTE_XPixelToPalette[val.foreground]; + val.background = X11DRV_PALETTE_XPixelToPalette[val.background]; } if (dc->w.flags & DC_DIRTY) CLIPPING_UpdateGCRegion(dc); @@ -126,7 +126,7 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors ) break; case FillTiled: - if (fMapColors && COLOR_PixelToPalette) + if (fMapColors && X11DRV_PALETTE_XPixelToPalette) { register int x, y; XImage *image; @@ -140,7 +140,7 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors ) for (y = 0; y < 8; y++) for (x = 0; x < 8; x++) XPutPixel( image, x, y, - COLOR_PixelToPalette[XGetPixel( image, x, y)] ); + X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y)] ); XPutImage( display, pixmap, gc, image, 0, 0, 0, 0, 8, 8 ); XDestroyImage( image ); LeaveCriticalSection( &X11DRV_CritSection ); @@ -829,7 +829,7 @@ X11DRV_SetPixel( DC *dc, INT x, INT y, COLORREF color ) x = dc->w.DCOrgX + XLPTODP( dc, x ); y = dc->w.DCOrgY + YLPTODP( dc, y ); - pixel = COLOR_ToPhysical( dc, color ); + pixel = X11DRV_PALETTE_ToPhysical( dc, color ); TSXSetForeground( display, physDev->gc, pixel ); TSXSetFunction( display, physDev->gc, GXcopy ); @@ -837,7 +837,7 @@ X11DRV_SetPixel( DC *dc, INT x, INT y, COLORREF color ) /* inefficient but simple... */ - return COLOR_ToLogical(pixel); + return X11DRV_PALETTE_ToLogical(pixel); } @@ -874,7 +874,7 @@ X11DRV_GetPixel( DC *dc, INT x, INT y ) XDestroyImage( image ); LeaveCriticalSection( &X11DRV_CritSection ); - return COLOR_ToLogical(pixel); + return X11DRV_PALETTE_ToLogical(pixel); } @@ -1171,7 +1171,7 @@ static BOOL X11DRV_DoFloodFill( const struct FloodFill_params *params ) YLPTODP(dc,params->y) + dc->w.DCOrgY - rect.top, rect.left, rect.top, - COLOR_ToPhysical( dc, params->color ), + X11DRV_PALETTE_ToPhysical( dc, params->color ), params->fillType ); } @@ -1416,7 +1416,7 @@ X11DRV_SetBkColor( DC *dc, COLORREF color ) oldColor = dc->w.backgroundColor; dc->w.backgroundColor = color; - physDev->backgroundPixel = COLOR_ToPhysical( dc, color ); + physDev->backgroundPixel = X11DRV_PALETTE_ToPhysical( dc, color ); return oldColor; } @@ -1433,7 +1433,7 @@ X11DRV_SetTextColor( DC *dc, COLORREF color ) oldColor = dc->w.textColor; dc->w.textColor = color; - physDev->textPixel = COLOR_ToPhysical( dc, color ); + physDev->textPixel = X11DRV_PALETTE_ToPhysical( dc, color ); return oldColor; } diff --git a/graphics/x11drv/init.c b/graphics/x11drv/init.c index 032a846e6b20c6a1d7684082a0ef1104306f27f1..dace94921ca0c7b8d0ca96814ccca01778bd0fa4 100644 --- a/graphics/x11drv/init.c +++ b/graphics/x11drv/init.c @@ -11,14 +11,15 @@ #include "ts_xlib.h" #include <string.h> -#include "x11drv.h" -#include "color.h" + #include "bitmap.h" -#include "winnt.h" -#include "local.h" +#include "color.h" #include "debug.h" #include "ldt.h" +#include "local.h" #include "monitor.h" +#include "winnt.h" +#include "x11drv.h" static BOOL X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device, LPCSTR output, const DEVMODE16* initData ); @@ -36,6 +37,8 @@ static const DC_FUNCTIONS X11DRV_Funcs = X11DRV_CreateBitmap, /* pCreateBitmap */ X11DRV_CreateDC, /* pCreateDC */ X11DRV_DeleteDC, /* pDeleteDC */ + X11DRV_DIB_CreateDIBSection, /* pCreateDIBSection */ + X11DRV_DIB_CreateDIBSection16, /* pCreateDIBSection16 */ X11DRV_DeleteObject, /* pDeleteObject */ X11DRV_Ellipse, /* pEllipse */ X11DRV_EnumDeviceFonts, /* pEnumDeviceFonts */ @@ -97,7 +100,26 @@ static const DC_FUNCTIONS X11DRV_Funcs = NULL /* pStretchDIBits */ }; -static DeviceCaps X11DRV_DevCaps = { +GDI_DRIVER X11DRV_GDI_Driver = +{ + X11DRV_GDI_Initialize, + X11DRV_GDI_Finalize +}; + +BITMAP_DRIVER X11DRV_BITMAP_Driver = +{ + X11DRV_DIB_SetDIBits, + X11DRV_DIB_GetDIBits, + X11DRV_DIB_DeleteDIBSection +}; + +PALETTE_DRIVER X11DRV_PALETTE_Driver = +{ + X11DRV_PALETTE_SetMapping, + X11DRV_PALETTE_UpdateMapping +}; + +DeviceCaps X11DRV_DevCaps = { /* version */ 0, /* technology */ DT_RASDISPLAY, /* size, resolution */ 0, 0, 0, 0, 0, @@ -120,15 +142,18 @@ static DeviceCaps X11DRV_DevCaps = { /* ..etc */ 0, 0 }; /********************************************************************** - * X11DRV_Init + * X11DRV_GDI_Initialize */ -BOOL X11DRV_Init(void) +BOOL X11DRV_GDI_Initialize(void) { + BITMAP_Driver = &X11DRV_BITMAP_Driver; + PALETTE_Driver = &X11DRV_PALETTE_Driver; + /* FIXME: colormap management should be merged with the X11DRV */ if( !X11DRV_DIB_Init() ) return FALSE; - if( !COLOR_Init() ) return FALSE; + if( !X11DRV_PALETTE_Init() ) return FALSE; if( !X11DRV_OBM_Init() ) return FALSE; @@ -146,14 +171,6 @@ BOOL X11DRV_Init(void) 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 - { - X11DRV_DevCaps.rasterCaps |= RC_PALETTE; - X11DRV_DevCaps.sizePalette = DefaultVisual(display,DefaultScreen(display))->map_entries; - } /* Resolution will be adjusted during the font init */ @@ -175,6 +192,14 @@ BOOL X11DRV_Init(void) return DRIVER_RegisterDriver( "DISPLAY", &X11DRV_Funcs ); } +/********************************************************************** + * X11DRV_GDI_Finalize + */ +void X11DRV_GDI_Finalize(void) +{ + X11DRV_PALETTE_Cleanup(); +} + /********************************************************************** * X11DRV_CreateDC */ diff --git a/graphics/x11drv/oembitmap.c b/graphics/x11drv/oembitmap.c index 4b9536fe0669a60cdd66529487df8982fa03a67a..d8095158f952a4aeeaf26e49a0a4e36996125bd6 100644 --- a/graphics/x11drv/oembitmap.c +++ b/graphics/x11drv/oembitmap.c @@ -322,10 +322,10 @@ static BOOL OBM_InitColorSymbols() for (i = 0; i < NB_COLOR_SYMBOLS; i++) { if (OBM_Colors[i].pixel & 0xff000000) /* PALETTEINDEX */ - OBM_Colors[i].pixel = COLOR_ToPhysical( NULL, + OBM_Colors[i].pixel = X11DRV_PALETTE_ToPhysical( NULL, GetSysColor(OBM_Colors[i].pixel & 0xff)); else /* RGB*/ - OBM_Colors[i].pixel = COLOR_ToPhysical( NULL, OBM_Colors[i].pixel); + OBM_Colors[i].pixel = X11DRV_PALETTE_ToPhysical( NULL, OBM_Colors[i].pixel); } return TRUE; } @@ -387,7 +387,7 @@ static BOOL OBM_CreateBitmaps( OBM_BITMAP_DESCR *descr ) attrs = (XpmAttributes *)HEAP_xalloc( GetProcessHeap(), 0, XpmAttributesSize() ); attrs->valuemask = XpmColormap | XpmDepth | XpmColorSymbols |XpmHotspot; - attrs->colormap = X11DRV_COLOR_GetColormap(); + attrs->colormap = X11DRV_PALETTE_PaletteXColormap; 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; @@ -543,7 +543,7 @@ static HGLOBAL16 OBM_LoadCursorIcon( WORD id, BOOL fCursor ) { X11DRV_PHYSBITMAP *pbitmapXor = bmpXor->DDBitmap->physBitmap; TSXSetForeground( display, BITMAP_colorGC, - COLOR_ToPhysical( NULL, RGB(0,0,0) )); + X11DRV_PALETTE_ToPhysical( NULL, RGB(0,0,0) )); TSXSetBackground( display, BITMAP_colorGC, 0 ); TSXSetFunction( display, BITMAP_colorGC, GXor ); TSXCopyPlane(display, pbitmapAnd->pixmap, pbitmapXor->pixmap, BITMAP_colorGC, diff --git a/graphics/x11drv/palette.c b/graphics/x11drv/palette.c new file mode 100644 index 0000000000000000000000000000000000000000..959f323a62d5c10757233d6b869ce59a7e72172d --- /dev/null +++ b/graphics/x11drv/palette.c @@ -0,0 +1,979 @@ +/* + * X11DRV OEM bitmap objects + * + * Copyright 1994, 1995 Alexandre Julliard + * + */ + +#include "config.h" + +#ifndef X_DISPLAY_MISSING + +#include "ts_xlib.h" + +#include <stdlib.h> +#include <string.h> + +#include "color.h" +#include "debug.h" +#include "gdi.h" +#include "monitor.h" +#include "options.h" +#include "palette.h" +#include "windef.h" +#include "xmalloc.h" +#include "x11drv.h" + +/* Palette indexed mode: + * logical palette -> mapping -> pixel + * + * + * Windows needs contiguous color space ( from 0 to n ) but + * it is possible only with the private colormap. Otherwise we + * have to map DC palette indices to real pixel values. With + * private colormaps it boils down to the identity mapping. The + * other special case is when we have a fixed color visual with + * the screendepth > 8 - we abandon palette mappings altogether + * because pixel values can be calculated without X server + * assistance. + * + * Windows palette manager is described in the + * http://premium.microsoft.com/msdn/library/techart/f30/f34/f40/d4d/sa942.htm + */ + +extern PALETTEENTRY *COLOR_sysPal; +extern int COLOR_gapStart; +extern int COLOR_gapEnd; +extern int COLOR_gapFilled; +extern int COLOR_max; + +extern const PALETTEENTRY COLOR_sysPalTemplate[NB_RESERVED_COLORS]; + +Colormap X11DRV_PALETTE_PaletteXColormap = 0; +UINT16 X11DRV_PALETTE_PaletteFlags = 0; + +static int X11DRV_PALETTE_Redshift = 0; /* to handle abortive X11DRV_PALETTE_VIRTUAL visuals */ +static int X11DRV_PALETTE_Redmax = 0; +static int X11DRV_PALETTE_Greenshift = 0; +static int X11DRV_PALETTE_Greenmax = 0; +static int X11DRV_PALETTE_Blueshift = 0; +static int X11DRV_PALETTE_Bluemax = 0; +static int X11DRV_PALETTE_Graymax = 0; + +/* First free dynamic color cell, 0 = full palette, -1 = fixed palette */ +static int X11DRV_PALETTE_firstFree = 0; +static unsigned char X11DRV_PALETTE_freeList[256]; + +/**********************************************************************/ + + /* Map an EGA index (0..15) to a pixel value in the system color space. */ + +int X11DRV_PALETTE_mapEGAPixel[16]; + +/**********************************************************************/ + +#define NB_COLORCUBE_START_INDEX 63 + +/* Maps entry in the system palette to X pixel value */ +int *X11DRV_PALETTE_PaletteToXPixel = NULL; + +/* Maps pixel to the entry in the system palette */ +int *X11DRV_PALETTE_XPixelToPalette = NULL; + +/**********************************************************************/ + +static BOOL X11DRV_PALETTE_BuildPrivateMap(void); +static BOOL X11DRV_PALETTE_BuildSharedMap(void); +static void X11DRV_PALETTE_ComputeShifts(unsigned long maskbits, int *shift, int *max); +static void X11DRV_PALETTE_FillDefaultColors(void); +static void X11DRV_PALETTE_FormatSystemPalette(void); +static BOOL X11DRV_PALETTE_CheckSysColor(COLORREF c); + +/*********************************************************************** + * COLOR_Init + * + * Initialize color management. + */ +BOOL X11DRV_PALETTE_Init(void) +{ + int mask, white, black; + int monoPlane; + + Visual *visual = DefaultVisual( display, DefaultScreen(display) ); + + TRACE(palette, "initializing palette manager...\n"); + + white = WhitePixelOfScreen( X11DRV_GetXScreen() ); + black = BlackPixelOfScreen( X11DRV_GetXScreen() ); + monoPlane = 1; + for( mask = 1; !((white & mask)^(black & mask)); mask <<= 1 ) + monoPlane++; + X11DRV_PALETTE_PaletteFlags = (white & mask) ? X11DRV_PALETTE_WHITESET : 0; + X11DRV_DevCaps.sizePalette = visual->map_entries; + + switch(visual->class) + { + case DirectColor: + X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_VIRTUAL; + case GrayScale: + case PseudoColor: + if (Options.usePrivateMap) + { + XSetWindowAttributes win_attr; + + X11DRV_PALETTE_PaletteXColormap = TSXCreateColormap( display, X11DRV_GetXRootWindow(), + visual, AllocAll ); + if (X11DRV_PALETTE_PaletteXColormap) + { + X11DRV_PALETTE_PaletteFlags |= (X11DRV_PALETTE_PRIVATE | X11DRV_PALETTE_WHITESET); + + monoPlane = 1; + for( white = X11DRV_DevCaps.sizePalette - 1; !(white & 1); white >>= 1 ) + monoPlane++; + + if( X11DRV_GetXRootWindow() != DefaultRootWindow(display) ) + { + win_attr.colormap = X11DRV_PALETTE_PaletteXColormap; + TSXChangeWindowAttributes( display, X11DRV_GetXRootWindow(), + CWColormap, &win_attr ); + } + break; + } + } + X11DRV_PALETTE_PaletteXColormap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); + break; + + case StaticGray: + X11DRV_PALETTE_PaletteXColormap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); + X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_FIXED; + X11DRV_PALETTE_Graymax = (1<<MONITOR_GetDepth(&MONITOR_PrimaryMonitor))-1; + break; + + case TrueColor: + X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_VIRTUAL; + case StaticColor: { + int *depths,nrofdepths; + /* FIXME: hack to detect XFree32 XF_VGA16 ... We just have + * depths 1 and 4 + */ + depths=TSXListDepths(display,DefaultScreen(display),&nrofdepths); + if ((nrofdepths==2) && ((depths[0]==4) || depths[1]==4)) { + monoPlane = 1; + for( white = X11DRV_DevCaps.sizePalette - 1; !(white & 1); white >>= 1 ) + monoPlane++; + X11DRV_PALETTE_PaletteFlags = (white & mask) ? X11DRV_PALETTE_WHITESET : 0; + X11DRV_PALETTE_PaletteXColormap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); + TSXFree(depths); + break; + } + TSXFree(depths); + X11DRV_PALETTE_PaletteXColormap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); + X11DRV_PALETTE_PaletteFlags |= X11DRV_PALETTE_FIXED; + X11DRV_PALETTE_ComputeShifts(visual->red_mask, &X11DRV_PALETTE_Redshift, &X11DRV_PALETTE_Redmax); + X11DRV_PALETTE_ComputeShifts(visual->green_mask, &X11DRV_PALETTE_Greenshift, &X11DRV_PALETTE_Greenmax); + X11DRV_PALETTE_ComputeShifts(visual->blue_mask, &X11DRV_PALETTE_Blueshift, &X11DRV_PALETTE_Bluemax); + break; + } + } + + TRACE(palette," visual class %i (%i)\n", visual->class, monoPlane); + + memset(X11DRV_PALETTE_freeList, 0, 256*sizeof(unsigned char)); + + if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE) + X11DRV_PALETTE_BuildPrivateMap(); + else + X11DRV_PALETTE_BuildSharedMap(); + + /* Build free list */ + + if( X11DRV_PALETTE_firstFree != -1 ) + X11DRV_PALETTE_FormatSystemPalette(); + + X11DRV_PALETTE_FillDefaultColors(); + + if( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL ) + X11DRV_DevCaps.sizePalette = 0; + else + { + X11DRV_DevCaps.rasterCaps |= RC_PALETTE; + X11DRV_DevCaps.sizePalette = visual->map_entries; + } + + return TRUE; +} + +/*********************************************************************** + * X11DRV_PALETTE_Cleanup + * + * Free external colors we grabbed in the FillDefaultPalette() + */ +void X11DRV_PALETTE_Cleanup(void) +{ + if( COLOR_gapFilled ) + TSXFreeColors(display, X11DRV_PALETTE_PaletteXColormap, + (unsigned long*)(X11DRV_PALETTE_PaletteToXPixel + COLOR_gapStart), + COLOR_gapFilled, 0); +} + +/*********************************************************************** + * X11DRV_PALETTE_ComputeShifts + * + * Calculate conversion parameters for direct mapped visuals + */ +static void X11DRV_PALETTE_ComputeShifts(unsigned long maskbits, int *shift, int *max) +{ + int i; + + if (maskbits==0) + { + *shift=0; + *max=0; + return; + } + + for(i=0;!(maskbits&1);i++) + maskbits >>= 1; + + *shift = i; + *max = maskbits; +} + +/*********************************************************************** + * X11DRV_PALETTE_BuildPrivateMap + * + * Allocate colorcells and initialize mapping tables. + */ +static BOOL X11DRV_PALETTE_BuildPrivateMap(void) +{ + /* Private colormap - identity mapping */ + + XColor color; + int i; + + COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*X11DRV_DevCaps.sizePalette); + + TRACE(palette,"Building private map - %i palette entries\n", X11DRV_DevCaps.sizePalette); + + /* Allocate system palette colors */ + + for( i=0; i < X11DRV_DevCaps.sizePalette; i++ ) + { + if( i < NB_RESERVED_COLORS/2 ) + { + color.red = COLOR_sysPalTemplate[i].peRed * 65535 / 255; + color.green = COLOR_sysPalTemplate[i].peGreen * 65535 / 255; + color.blue = COLOR_sysPalTemplate[i].peBlue * 65535 / 255; + COLOR_sysPal[i] = COLOR_sysPalTemplate[i]; + } + else if( i >= X11DRV_DevCaps.sizePalette - NB_RESERVED_COLORS/2 ) + { + int j = NB_RESERVED_COLORS + i - X11DRV_DevCaps.sizePalette; + color.red = COLOR_sysPalTemplate[j].peRed * 65535 / 255; + color.green = COLOR_sysPalTemplate[j].peGreen * 65535 / 255; + color.blue = COLOR_sysPalTemplate[j].peBlue * 65535 / 255; + COLOR_sysPal[i] = COLOR_sysPalTemplate[j]; + } + + color.flags = DoRed | DoGreen | DoBlue; + color.pixel = i; + TSXStoreColor(display, X11DRV_PALETTE_PaletteXColormap, &color); + + /* Set EGA mapping if color is from the first or last eight */ + + if (i < 8) + X11DRV_PALETTE_mapEGAPixel[i] = color.pixel; + else if (i >= X11DRV_DevCaps.sizePalette - 8 ) + X11DRV_PALETTE_mapEGAPixel[i - (X11DRV_DevCaps.sizePalette - 16)] = color.pixel; + } + + X11DRV_PALETTE_XPixelToPalette = X11DRV_PALETTE_PaletteToXPixel = NULL; + + COLOR_gapStart = 256; COLOR_gapEnd = -1; + + X11DRV_PALETTE_firstFree = (X11DRV_DevCaps.sizePalette > NB_RESERVED_COLORS)?NB_RESERVED_COLORS/2 : -1; + + return FALSE; +} + +/*********************************************************************** + * X11DRV_PALETTE_BuildSharedMap + * + * Allocate colorcells and initialize mapping tables. + */ +static BOOL X11DRV_PALETTE_BuildSharedMap(void) +{ + XColor color; + unsigned long sysPixel[NB_RESERVED_COLORS]; + unsigned long* pixDynMapping = NULL; + unsigned long plane_masks[1]; + int i, j, warn = 0; + int diff, r, g, b, max = 256, bp = 0, wp = 1; + int step = 1; + + /* read "AllocSystemColors" from wine.conf */ + + COLOR_max = PROFILE_GetWineIniInt( "options", "AllocSystemColors", 256); + if (COLOR_max > 256) COLOR_max = 256; + else if (COLOR_max < 20) COLOR_max = 20; + TRACE(palette,"%d colors configured.\n", COLOR_max); + + TRACE(palette,"Building shared map - %i palette entries\n", X11DRV_DevCaps.sizePalette); + + /* Be nice and allocate system colors as read-only */ + + for( i = 0; i < NB_RESERVED_COLORS; i++ ) + { + color.red = COLOR_sysPalTemplate[i].peRed * 65535 / 255; + color.green = COLOR_sysPalTemplate[i].peGreen * 65535 / 255; + color.blue = COLOR_sysPalTemplate[i].peBlue * 65535 / 255; + color.flags = DoRed | DoGreen | DoBlue; + + if (!TSXAllocColor( display, X11DRV_PALETTE_PaletteXColormap, &color )) + { + XColor best, c; + + if( !warn++ ) + { + WARN(palette, "Not enough colors for the full system palette.\n"); + + bp = BlackPixel(display, DefaultScreen(display)); + wp = WhitePixel(display, DefaultScreen(display)); + + max = (0xffffffff)>>(32 - MONITOR_GetDepth(&MONITOR_PrimaryMonitor)); + if( max > 256 ) + { + step = max/256; + max = 256; + } + } + + /* reinit color (XAllocColor() may change it) + * and map to the best shared colorcell */ + + color.red = COLOR_sysPalTemplate[i].peRed * 65535 / 255; + color.green = COLOR_sysPalTemplate[i].peGreen * 65535 / 255; + color.blue = COLOR_sysPalTemplate[i].peBlue * 65535 / 255; + + best.pixel = best.red = best.green = best.blue = 0; + for( c.pixel = 0, diff = 0x7fffffff; c.pixel < max; c.pixel += step ) + { + TSXQueryColor(display, X11DRV_PALETTE_PaletteXColormap, &c); + r = (c.red - color.red)>>8; + g = (c.green - color.green)>>8; + b = (c.blue - color.blue)>>8; + r = r*r + g*g + b*b; + if( r < diff ) { best = c; diff = r; } + } + + if( TSXAllocColor(display, X11DRV_PALETTE_PaletteXColormap, &best) ) + color.pixel = best.pixel; + else color.pixel = (i < NB_RESERVED_COLORS/2)? bp : wp; + } + + sysPixel[i] = color.pixel; + + TRACE(palette,"syscolor(%lx) -> pixel %i\n", + *(COLORREF*)(COLOR_sysPalTemplate+i), (int)color.pixel); + + /* Set EGA mapping if color in the first or last eight */ + + if (i < 8) + X11DRV_PALETTE_mapEGAPixel[i] = color.pixel; + else if (i >= NB_RESERVED_COLORS - 8 ) + X11DRV_PALETTE_mapEGAPixel[i - (NB_RESERVED_COLORS-16)] = color.pixel; + } + + /* now allocate changeable set */ + + if( !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) ) + { + int c_min = 0, c_max = X11DRV_DevCaps.sizePalette, c_val; + + TRACE(palette,"Dynamic colormap... \n"); + + /* comment this out if you want to debug palette init */ + + TSXGrabServer(display); + + /* let's become the first client that actually follows + * X guidelines and does binary search... + */ + + pixDynMapping = (unsigned long*)xmalloc(sizeof(long)*X11DRV_DevCaps.sizePalette); + while( c_max - c_min > 0 ) + { + c_val = (c_max + c_min)/2 + (c_max + c_min)%2; + + if( !TSXAllocColorCells(display, X11DRV_PALETTE_PaletteXColormap, False, + plane_masks, 0, pixDynMapping, c_val) ) + c_max = c_val - 1; + else + { + TSXFreeColors(display, X11DRV_PALETTE_PaletteXColormap, pixDynMapping, c_val, 0); + c_min = c_val; + } + } + + if( c_min > COLOR_max - NB_RESERVED_COLORS) + c_min = COLOR_max - NB_RESERVED_COLORS; + + c_min = (c_min/2) + (c_min/2); /* need even set for split palette */ + + if( c_min > 0 ) + if( !TSXAllocColorCells(display, X11DRV_PALETTE_PaletteXColormap, False, + plane_masks, 0, pixDynMapping, c_min) ) + { + WARN(palette,"Inexplicable failure during colorcell allocation.\n"); + c_min = 0; + } + + X11DRV_DevCaps.sizePalette = c_min + NB_RESERVED_COLORS; + + TSXUngrabServer(display); + + TRACE(palette,"adjusted size %i colorcells\n", X11DRV_DevCaps.sizePalette); + } + else if( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL ) + { + /* virtual colorspace - ToPhysical takes care of + * color translations but we have to allocate full palette + * to maintain compatibility + */ + X11DRV_DevCaps.sizePalette = 256; + TRACE(palette,"Virtual colorspace - screendepth %i\n", MONITOR_GetDepth(&MONITOR_PrimaryMonitor)); + } + else X11DRV_DevCaps.sizePalette = NB_RESERVED_COLORS; /* system palette only - however we can alloc a bunch + * of colors and map to them */ + + TRACE(palette,"Shared system palette uses %i colors.\n", X11DRV_DevCaps.sizePalette); + + /* set gap to account for pixel shortage. It has to be right in the center + * of the system palette because otherwise raster ops get screwed. */ + + if( X11DRV_DevCaps.sizePalette >= 256 ) + { COLOR_gapStart = 256; COLOR_gapEnd = -1; } + else + { COLOR_gapStart = X11DRV_DevCaps.sizePalette/2; COLOR_gapEnd = 255 - X11DRV_DevCaps.sizePalette/2; } + + X11DRV_PALETTE_firstFree = ( X11DRV_DevCaps.sizePalette > NB_RESERVED_COLORS && + (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL || !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED)) ) + ? NB_RESERVED_COLORS/2 : -1; + + COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*256); + + /* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */ + + if( MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8 ) + { + X11DRV_PALETTE_XPixelToPalette = (int*)xmalloc(sizeof(int)*256); + memset( X11DRV_PALETTE_XPixelToPalette, 0, 256*sizeof(int) ); + } + + /* for hicolor visuals PaletteToPixel mapping is used to skip + * RGB->pixel calculation in X11DRV_PALETTE_ToPhysical(). + */ + + X11DRV_PALETTE_PaletteToXPixel = (int*)xmalloc(sizeof(int)*256); + + for( i = j = 0; i < 256; i++ ) + { + if( i >= COLOR_gapStart && i <= COLOR_gapEnd ) + { + X11DRV_PALETTE_PaletteToXPixel[i] = 0; + COLOR_sysPal[i].peFlags = 0; /* mark as unused */ + continue; + } + + if( i < NB_RESERVED_COLORS/2 ) + { + X11DRV_PALETTE_PaletteToXPixel[i] = sysPixel[i]; + COLOR_sysPal[i] = COLOR_sysPalTemplate[i]; + } + else if( i >= 256 - NB_RESERVED_COLORS/2 ) + { + X11DRV_PALETTE_PaletteToXPixel[i] = sysPixel[(i + NB_RESERVED_COLORS) - 256]; + COLOR_sysPal[i] = COLOR_sysPalTemplate[(i + NB_RESERVED_COLORS) - 256]; + } + else if( pixDynMapping ) + X11DRV_PALETTE_PaletteToXPixel[i] = pixDynMapping[j++]; + else + X11DRV_PALETTE_PaletteToXPixel[i] = i; + + TRACE(palette,"index %i -> pixel %i\n", i, X11DRV_PALETTE_PaletteToXPixel[i]); + + if( X11DRV_PALETTE_XPixelToPalette ) + X11DRV_PALETTE_XPixelToPalette[X11DRV_PALETTE_PaletteToXPixel[i]] = i; + } + + if( pixDynMapping ) free(pixDynMapping); + + return TRUE; +} + +/*********************************************************************** + * Colormap Initialization + */ +static void X11DRV_PALETTE_FillDefaultColors(void) +{ + /* initialize unused entries to what Windows uses as a color + * cube - based on Greg Kreider's code. + */ + + int i = 0, idx = 0; + int red, no_r, inc_r; + int green, no_g, inc_g; + int blue, no_b, inc_b; + + if (X11DRV_DevCaps.sizePalette <= NB_RESERVED_COLORS) + return; + while (i*i*i < (X11DRV_DevCaps.sizePalette - NB_RESERVED_COLORS)) i++; + no_r = no_g = no_b = --i; + if ((no_r * (no_g+1) * no_b) < (X11DRV_DevCaps.sizePalette - NB_RESERVED_COLORS)) no_g++; + if ((no_r * no_g * (no_b+1)) < (X11DRV_DevCaps.sizePalette - NB_RESERVED_COLORS)) no_b++; + inc_r = (255 - NB_COLORCUBE_START_INDEX)/no_r; + inc_g = (255 - NB_COLORCUBE_START_INDEX)/no_g; + inc_b = (255 - NB_COLORCUBE_START_INDEX)/no_b; + + idx = X11DRV_PALETTE_firstFree; + + if( idx != -1 ) + for (blue = NB_COLORCUBE_START_INDEX; blue < 256 && idx; blue += inc_b ) + for (green = NB_COLORCUBE_START_INDEX; green < 256 && idx; green += inc_g ) + for (red = NB_COLORCUBE_START_INDEX; red < 256 && idx; red += inc_r ) + { + /* weird but true */ + + if( red == NB_COLORCUBE_START_INDEX && green == red && blue == green ) continue; + + COLOR_sysPal[idx].peRed = red; + COLOR_sysPal[idx].peGreen = green; + COLOR_sysPal[idx].peBlue = blue; + + /* set X color */ + + if( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL ) + { + if (X11DRV_PALETTE_Redmax != 255) no_r = (red * X11DRV_PALETTE_Redmax) / 255; + if (X11DRV_PALETTE_Greenmax != 255) no_g = (green * X11DRV_PALETTE_Greenmax) / 255; + if (X11DRV_PALETTE_Bluemax != 255) no_b = (blue * X11DRV_PALETTE_Bluemax) / 255; + + X11DRV_PALETTE_PaletteToXPixel[idx] = (no_r << X11DRV_PALETTE_Redshift) | (no_g << X11DRV_PALETTE_Greenshift) | (no_b << X11DRV_PALETTE_Blueshift); + } + else if( !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) ) + { + XColor color = { color.pixel = (X11DRV_PALETTE_PaletteToXPixel)? X11DRV_PALETTE_PaletteToXPixel[idx] : idx , + COLOR_sysPal[idx].peRed << 8, + COLOR_sysPal[idx].peGreen << 8, + COLOR_sysPal[idx].peGreen << 8, + (DoRed | DoGreen | DoBlue) }; + TSXStoreColor(display, X11DRV_PALETTE_PaletteXColormap, &color); + } + idx = X11DRV_PALETTE_freeList[idx]; + } + + /* try to fill some entries in the "gap" with + * what's already in the colormap - they will be + * mappable to but not changeable. */ + + if( COLOR_gapStart < COLOR_gapEnd && X11DRV_PALETTE_XPixelToPalette ) + { + XColor xc; + int r, g, b, max; + + max = COLOR_max - (256 - (COLOR_gapEnd - COLOR_gapStart)); + for ( i = 0, idx = COLOR_gapStart; i < 256 && idx <= COLOR_gapEnd; i++ ) + if( X11DRV_PALETTE_XPixelToPalette[i] == 0 ) + { + xc.pixel = i; + + TSXQueryColor(display, X11DRV_PALETTE_PaletteXColormap, &xc); + r = xc.red>>8; g = xc.green>>8; b = xc.blue>>8; + + if( xc.pixel < 256 && X11DRV_PALETTE_CheckSysColor(RGB(r, g, b)) && + TSXAllocColor(display, X11DRV_PALETTE_PaletteXColormap, &xc) ) + { + X11DRV_PALETTE_XPixelToPalette[xc.pixel] = idx; + X11DRV_PALETTE_PaletteToXPixel[idx] = xc.pixel; + *(COLORREF*)(COLOR_sysPal + idx) = RGB(r, g, b); + COLOR_sysPal[idx++].peFlags |= PC_SYS_USED; + if( --max <= 0 ) break; + } + } + COLOR_gapFilled = idx - COLOR_gapStart; + } +} + + +/*********************************************************************** + * X11DRV_PALETTE_ToLogical + * + * Return RGB color for given X pixel. + */ +COLORREF X11DRV_PALETTE_ToLogical(int pixel) +{ + XColor color; + +#if 0 + /* truecolor visual */ + + if (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) >= 24) return pixel; +#endif + + /* check for hicolor visuals first */ + + if ( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED && !X11DRV_PALETTE_Graymax ) + { + color.red = (pixel >> X11DRV_PALETTE_Redshift) & X11DRV_PALETTE_Redmax; + color.green = (pixel >> X11DRV_PALETTE_Greenshift) & X11DRV_PALETTE_Greenmax; + color.blue = (pixel >> X11DRV_PALETTE_Blueshift) & X11DRV_PALETTE_Bluemax; + return RGB((color.red * 255)/X11DRV_PALETTE_Redmax, + (color.green * 255)/X11DRV_PALETTE_Greenmax, + (color.blue * 255)/X11DRV_PALETTE_Bluemax); + } + + /* check if we can bypass X */ + + if ((MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8) && (pixel < 256) && + !(X11DRV_PALETTE_PaletteFlags & (X11DRV_PALETTE_VIRTUAL | X11DRV_PALETTE_FIXED)) ) + return ( *(COLORREF*)(COLOR_sysPal + + ((X11DRV_PALETTE_XPixelToPalette)?X11DRV_PALETTE_XPixelToPalette[pixel]:pixel)) ) & 0x00ffffff; + + color.pixel = pixel; + TSXQueryColor(display, X11DRV_PALETTE_PaletteXColormap, &color); + return RGB(color.red >> 8, color.green >> 8, color.blue >> 8); +} + +/*********************************************************************** + * X11DRV_PALETTE_ToPhysical + * + * Return the physical color closest to 'color'. + */ +int X11DRV_PALETTE_ToPhysical( DC *dc, COLORREF color ) +{ + WORD index = 0; + HPALETTE16 hPal = (dc)? dc->w.hPalette: STOCK_DEFAULT_PALETTE; + unsigned char spec_type = color >> 24; + PALETTEOBJ* palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC ); + + if ( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED ) + { + /* there is no colormap limitation; we are going to have to compute + * the pixel value from the visual information stored earlier + */ + + unsigned long red, green, blue; + unsigned idx = 0; + + switch(spec_type) + { + case 2: /* PALETTERGB - not sure if we really need to search palette */ + + idx = COLOR_PaletteLookupPixel( palPtr->logpalette.palPalEntry, + palPtr->logpalette.palNumEntries, + NULL, color, FALSE); + + if( palPtr->mapping ) + { + GDI_HEAP_UNLOCK( hPal ); + return palPtr->mapping[idx]; + } + + color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx); + break; + + case 1: /* PALETTEINDEX */ + + if( (idx = color & 0xffff) >= palPtr->logpalette.palNumEntries) + { + WARN(palette, "RGB(%lx) : idx %d is out of bounds, assuming black\n", color, idx); + GDI_HEAP_UNLOCK( hPal ); + return 0; + } + + if( palPtr->mapping ) + { + GDI_HEAP_UNLOCK( hPal ); + return palPtr->mapping[idx]; + } + color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx); + break; + + default: + color &= 0xffffff; + /* fall through to RGB */ + + case 0: /* RGB */ + if( dc && (dc->w.bitsPerPixel == 1) ) + { + GDI_HEAP_UNLOCK( hPal ); + return (((color >> 16) & 0xff) + + ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0; + } + + } + + red = GetRValue(color); green = GetGValue(color); blue = GetBValue(color); + + if (X11DRV_PALETTE_Graymax) + { + /* grayscale only; return scaled value */ + GDI_HEAP_UNLOCK( hPal ); + return ( (red * 30 + green * 69 + blue * 11) * X11DRV_PALETTE_Graymax) / 25500; + } + else + { + /* scale each individually and construct the TrueColor pixel value */ + if (X11DRV_PALETTE_Redmax != 255) red = (red * X11DRV_PALETTE_Redmax) / 255; + if (X11DRV_PALETTE_Greenmax != 255) green = (green * X11DRV_PALETTE_Greenmax) / 255; + if (X11DRV_PALETTE_Bluemax != 255) blue = (blue * X11DRV_PALETTE_Bluemax) / 255; + + GDI_HEAP_UNLOCK( hPal ); + return (red << X11DRV_PALETTE_Redshift) | (green << X11DRV_PALETTE_Greenshift) | (blue << X11DRV_PALETTE_Blueshift); + } + } + else + { + + /* palPtr can be NULL when DC is being destroyed */ + + if( !palPtr ) return 0; + else if( !palPtr->mapping ) + WARN(palette, "Palette %04x is not realized\n", dc->w.hPalette); + + switch(spec_type) /* we have to peruse DC and system palette */ + { + default: + color &= 0xffffff; + /* fall through to RGB */ + + case 0: /* RGB */ + if( dc && (dc->w.bitsPerPixel == 1) ) + { + GDI_HEAP_UNLOCK( hPal ); + return (((color >> 16) & 0xff) + + ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0; + } + + index = COLOR_PaletteLookupPixel( COLOR_sysPal, 256, + X11DRV_PALETTE_PaletteToXPixel, color, FALSE); + + /* TRACE(palette,"RGB(%lx) -> pixel %i\n", color, index); + */ + break; + case 1: /* PALETTEINDEX */ + index = color & 0xffff; + + if( index >= palPtr->logpalette.palNumEntries ) + WARN(palette, "RGB(%lx) : index %i is out of bounds\n", color, index); + else if( palPtr->mapping ) index = palPtr->mapping[index]; + + /* TRACE(palette,"PALETTEINDEX(%04x) -> pixel %i\n", (WORD)color, index); + */ + break; + case 2: /* PALETTERGB */ + index = COLOR_PaletteLookupPixel( palPtr->logpalette.palPalEntry, + palPtr->logpalette.palNumEntries, + palPtr->mapping, color, FALSE); + /* TRACE(palette,"PALETTERGB(%lx) -> pixel %i\n", color, index); + */ + break; + } + } + + GDI_HEAP_UNLOCK( hPal ); + return index; +} + +/*********************************************************************** + * X11DRV_PALETTE_LookupSystemXPixel + */ +int X11DRV_PALETTE_LookupSystemXPixel(COLORREF col) +{ + int i, best = 0, diff = 0x7fffffff; + int size = X11DRV_DevCaps.sizePalette; + int r,g,b; + + for( i = 0; i < size && diff ; i++ ) + { + if( i == NB_RESERVED_COLORS/2 ) + { + int newi = size - NB_RESERVED_COLORS/2; + if (newi>i) i=newi; + } + + r = COLOR_sysPal[i].peRed - GetRValue(col); + g = COLOR_sysPal[i].peGreen - GetGValue(col); + b = COLOR_sysPal[i].peBlue - GetBValue(col); + + r = r*r + g*g + b*b; + + if( r < diff ) { best = i; diff = r; } + } + + return (X11DRV_PALETTE_PaletteToXPixel)? X11DRV_PALETTE_PaletteToXPixel[best] : best; +} + +/*********************************************************************** + * X11DRV_PALETTE_FormatSystemPalette + */ +static void X11DRV_PALETTE_FormatSystemPalette(void) +{ + /* Build free list so we'd have an easy way to find + * out if there are any available colorcells. + */ + + int i, j = X11DRV_PALETTE_firstFree = NB_RESERVED_COLORS/2; + + COLOR_sysPal[j].peFlags = 0; + for( i = NB_RESERVED_COLORS/2 + 1 ; i < 256 - NB_RESERVED_COLORS/2 ; i++ ) + if( i < COLOR_gapStart || i > COLOR_gapEnd ) + { + COLOR_sysPal[i].peFlags = 0; /* unused tag */ + X11DRV_PALETTE_freeList[j] = i; /* next */ + j = i; + } + X11DRV_PALETTE_freeList[j] = 0; +} + +/*********************************************************************** + * X11DRV_PALETTE_CheckSysColor + */ +static BOOL X11DRV_PALETTE_CheckSysColor(COLORREF c) +{ + int i; + for( i = 0; i < NB_RESERVED_COLORS; i++ ) + if( c == (*(COLORREF*)(COLOR_sysPalTemplate + i) & 0x00ffffff) ) + return 0; + return 1; +} + +/*********************************************************************** + * X11DRV_PALETTE_SetMapping + * + * Set the color-mapping table for selected palette. + * Return number of entries which mapping has changed. + */ +int X11DRV_PALETTE_SetMapping( PALETTEOBJ* palPtr, UINT uStart, UINT uNum, BOOL mapOnly ) +{ + char flag; + int prevMapping = (palPtr->mapping) ? 1 : 0; + int index, iRemapped = 0; + + /* reset dynamic system palette entries */ + + if( !mapOnly && X11DRV_PALETTE_firstFree != -1) + X11DRV_PALETTE_FormatSystemPalette(); + + /* initialize palette mapping table */ + + palPtr->mapping = (int*)xrealloc(palPtr->mapping, sizeof(int)* + palPtr->logpalette.palNumEntries); + + for( uNum += uStart; uStart < uNum; uStart++ ) + { + index = -1; + flag = PC_SYS_USED; + + switch( palPtr->logpalette.palPalEntry[uStart].peFlags & 0x07 ) + { + case PC_EXPLICIT: /* palette entries are indices into system palette */ + index = *(WORD*)(palPtr->logpalette.palPalEntry + uStart); + if( index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd) ) + { + WARN(palette,"PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index); + index = 0; + } + break; + + case PC_RESERVED: /* forbid future mappings to this entry */ + flag |= PC_SYS_RESERVED; + + /* fall through */ + default: /* try to collapse identical colors */ + index = COLOR_PaletteLookupExactIndex(COLOR_sysPal, 256, + *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart)); + /* fall through */ + case PC_NOCOLLAPSE: + if( index < 0 ) + { + if( X11DRV_PALETTE_firstFree > 0 && !(X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_FIXED) ) + { + XColor color; + index = X11DRV_PALETTE_firstFree; /* ought to be available */ + X11DRV_PALETTE_firstFree = X11DRV_PALETTE_freeList[index]; + + color.pixel = (X11DRV_PALETTE_PaletteToXPixel) ? X11DRV_PALETTE_PaletteToXPixel[index] : index; + color.red = palPtr->logpalette.palPalEntry[uStart].peRed << 8; + color.green = palPtr->logpalette.palPalEntry[uStart].peGreen << 8; + color.blue = palPtr->logpalette.palPalEntry[uStart].peBlue << 8; + color.flags = DoRed | DoGreen | DoBlue; + TSXStoreColor(display, X11DRV_PALETTE_PaletteXColormap, &color); + + COLOR_sysPal[index] = palPtr->logpalette.palPalEntry[uStart]; + COLOR_sysPal[index].peFlags = flag; + X11DRV_PALETTE_freeList[index] = 0; + + if( X11DRV_PALETTE_PaletteToXPixel ) index = X11DRV_PALETTE_PaletteToXPixel[index]; + break; + } + else if ( X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_VIRTUAL ) + { + index = X11DRV_PALETTE_ToPhysical( NULL, 0x00ffffff & + *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart)); + break; + } + + /* we have to map to existing entry in the system palette */ + + index = COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL, + *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart), TRUE); + } + palPtr->logpalette.palPalEntry[uStart].peFlags |= PC_SYS_USED; + + if( X11DRV_PALETTE_PaletteToXPixel ) index = X11DRV_PALETTE_PaletteToXPixel[index]; + break; + } + + if( !prevMapping || palPtr->mapping[uStart] != index ) iRemapped++; + palPtr->mapping[uStart] = index; + + TRACE(palette,"entry %i (%lx) -> pixel %i\n", uStart, + *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart), index); + + } + return iRemapped; +} + +/*********************************************************************** + * X11DRV_PALETTE_UpdateMapping + * + * Update the color-mapping table for selected palette. + * Return number of entries which mapping has changed. + */ +int X11DRV_PALETTE_UpdateMapping(PALETTEOBJ *palPtr) +{ + int i, index, realized = 0; + + for( i = 0; i < 20; i++ ) + { + index = X11DRV_PALETTE_LookupSystemXPixel(*(COLORREF*)(palPtr->logpalette.palPalEntry + i)); + + /* mapping is allocated in COLOR_InitPalette() */ + + if( index != palPtr->mapping[i] ) { palPtr->mapping[i]=index; realized++; } + } + + return realized; +} + +/************************************************************************** + * X11DRV_PALETTE_IsDark + */ +BOOL X11DRV_PALETTE_IsDark(int pixel) +{ + COLORREF col = X11DRV_PALETTE_ToLogical(pixel); + return (GetRValue(col) + GetGValue(col) + GetBValue(col)) <= 0x180; +} + +#endif /* !defined(X_DISPLAY_MISSING) */ diff --git a/graphics/x11drv/pen.c b/graphics/x11drv/pen.c index f951bf82344885da7c1cc1359656f68a2028d2db..76bb905e2914d9de3f5e2df9f66d09fbaeddcfbd 100644 --- a/graphics/x11drv/pen.c +++ b/graphics/x11drv/pen.c @@ -37,7 +37,7 @@ HPEN X11DRV_PEN_SelectObject( DC * dc, HPEN hpen, PENOBJ * pen ) dc->wndExtX / 2) / dc->wndExtX; if (physDev->pen.width < 0) physDev->pen.width = -physDev->pen.width; if (physDev->pen.width == 1) physDev->pen.width = 0; /* Faster */ - physDev->pen.pixel = COLOR_ToPhysical( dc, pen->logpen.lopnColor ); + physDev->pen.pixel = X11DRV_PALETTE_ToPhysical( dc, pen->logpen.lopnColor ); switch(pen->logpen.lopnStyle & PS_STYLE_MASK) { case PS_DASH: diff --git a/include/bitmap.h b/include/bitmap.h index 27f0b5c3f061be84c34092ff9b5dad7f4f46bd72..6e3894e4a2d9c0c1a6c42bb47de1b6ee7b0246ac 100644 --- a/include/bitmap.h +++ b/include/bitmap.h @@ -7,30 +7,9 @@ #ifndef __WINE_BITMAP_H #define __WINE_BITMAP_H -#include <X11/Xlib.h> - #include "gdi.h" - /* Additional info for DIB section objects */ -typedef struct -{ - /* Windows DIB section */ - DIBSECTION dibSection; - - /* Mapping status */ - enum { DIB_NoHandler, DIB_InSync, DIB_AppMod, DIB_GdiMod } status; - - /* Color map info */ - int nColorMap; - int *colorMap; - - /* Cached XImage */ - XImage *image; - - /* Selector for 16-bit access to bits */ - WORD selector; - -} DIBSECTIONOBJ; +struct tagGDI_BITMAP_DRIVER; /* Flags used for BitmapBits. We only use the first two at the moment */ @@ -48,16 +27,24 @@ typedef struct { typedef struct tagBITMAPOBJ { GDIOBJHDR header; - BITMAP bitmap; - SIZE size; /* For SetBitmapDimension() */ + BITMAP bitmap; + SIZE size; /* For SetBitmapDimension() */ - DDBITMAP *DDBitmap; + DDBITMAP *DDBitmap; /* For device-independent bitmaps: */ - DIBSECTIONOBJ *dib; - + DIBSECTION *dib; } BITMAPOBJ; +typedef struct tagBITMAP_DRIVER +{ + INT (*pSetDIBits)(struct tagBITMAPOBJ *,struct tagDC *,UINT,UINT,LPCVOID,const BITMAPINFO *,UINT,HBITMAP); + INT (*pGetDIBits)(struct tagBITMAPOBJ *,struct tagDC *,UINT,UINT,LPVOID,BITMAPINFO *,UINT,HBITMAP); + VOID (*pDeleteDIBSection)(struct tagBITMAPOBJ *); +} BITMAP_DRIVER; + +extern BITMAP_DRIVER *BITMAP_Driver; + /* objects/bitmap.c */ extern INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer ); extern INT BITMAP_GetObject( BITMAPOBJ * bmp, INT count, LPVOID buffer ); diff --git a/include/clipboard.h b/include/clipboard.h index 7d0c282e7eb46bc4bb83e5371f048913c6923fe1..605e3575fffc040dac85be563f8f10e51ab29c18 100644 --- a/include/clipboard.h +++ b/include/clipboard.h @@ -1,9 +1,10 @@ #ifndef __WINE_CLIPBOARD_H #define __WINE_CLIPBOARD_H -#include "win.h" #include "windef.h" +struct tagWND; + typedef struct tagWINE_CLIPFORMAT { WORD wFormatID; WORD wRefCount; @@ -16,15 +17,15 @@ typedef struct tagWINE_CLIPFORMAT { HANDLE16 hData16; } WINE_CLIPFORMAT, *LPWINE_CLIPFORMAT; -typedef struct _CLIPBOARD_DRIVER +typedef struct tagCLIPBOARD_DRIVER { void (*pEmptyClipboard)(void); void (*pSetClipboardData)(UINT); BOOL (*pRequestSelection)(void); - void (*pResetOwner)(WND *, BOOL); + void (*pResetOwner)(struct tagWND *, BOOL); } CLIPBOARD_DRIVER; -CLIPBOARD_DRIVER *CLIPBOARD_GetDriver(void); +extern CLIPBOARD_DRIVER *CLIPBOARD_Driver; extern void CLIPBOARD_ResetLock(HQUEUE16 hqRef, HQUEUE16 hqNew); extern void CLIPBOARD_DeleteRecord(LPWINE_CLIPFORMAT lpFormat, BOOL bChange); diff --git a/include/color.h b/include/color.h index 4907ab2ee342fae6116a60e75f8af1851cc2970a..793fc2c785f985b00d36a278bbf44435f2666e55 100644 --- a/include/color.h +++ b/include/color.h @@ -1,38 +1,20 @@ #ifndef __WINE_COLOR_H #define __WINE_COLOR_H +#include "wingdi.h" #include "palette.h" -#include "gdi.h" - -#define COLOR_FIXED 0x0001 /* read-only colormap - have to use XAllocColor (if not virtual)*/ -#define COLOR_VIRTUAL 0x0002 /* no mapping needed - pixel == pixel color */ - -#define COLOR_PRIVATE 0x1000 /* private colormap, identity mapping */ -#define COLOR_WHITESET 0x2000 #define PC_SYS_USED 0x80 /* palentry is used (both system and logical) */ #define PC_SYS_RESERVED 0x40 /* system palentry is not to be mapped to */ #define PC_SYS_MAPPED 0x10 /* logical palentry is a direct alias for system palentry */ -extern BOOL COLOR_Init(void); -extern void COLOR_Cleanup(void); -extern COLORREF COLOR_ToLogical(int pixel); -extern int COLOR_ToPhysical( DC *dc, COLORREF color ); -extern int COLOR_SetMapping( PALETTEOBJ* pal, UINT uStart, UINT uNum, BOOL mapOnly ); -extern BOOL COLOR_IsSolid( COLORREF color ); -extern UINT16 COLOR_GetSystemPaletteSize(void); -extern UINT16 COLOR_GetSystemPaletteFlags(void); -extern const PALETTEENTRY* COLOR_GetSystemPaletteTemplate(void); -extern BOOL COLOR_GetMonoPlane( int* ); +extern BOOL COLOR_IsSolid(COLORREF color); -extern COLORREF COLOR_LookupNearestColor( PALETTEENTRY*, int, COLORREF ); -extern int COLOR_PaletteLookupPixel( PALETTEENTRY*, int, int* , COLORREF, BOOL ); -extern COLORREF COLOR_GetSystemPaletteEntry(UINT); -extern int COLOR_LookupSystemPixel(COLORREF col); +extern COLORREF COLOR_GetSystemPaletteEntry(UINT); +extern const PALETTEENTRY *COLOR_GetSystemPaletteTemplate(void); -extern int COLOR_mapEGAPixel[16]; -extern int* COLOR_PaletteToPixel; -extern int* COLOR_PixelToPalette; -extern int COLOR_ColormapSize; +extern COLORREF COLOR_LookupNearestColor(PALETTEENTRY *, int, COLORREF); +extern int COLOR_PaletteLookupExactIndex(PALETTEENTRY *palPalEntry, int size, COLORREF col); +extern int COLOR_PaletteLookupPixel(PALETTEENTRY *, int, int * , COLORREF, BOOL); #endif /* __WINE_COLOR_H */ diff --git a/include/desktop.h b/include/desktop.h index e049562b767591946001fd471c2639fcec5c8cac..3d1248162195b8d79ab78c91d494c546d4cab7c8 100644 --- a/include/desktop.h +++ b/include/desktop.h @@ -9,10 +9,9 @@ #include "windef.h" +struct tagDESKTOP_DRIVER; struct tagMONITOR; -struct _DESKTOP_DRIVER; - typedef struct tagDESKTOP { HBRUSH hbrushPattern; @@ -20,15 +19,18 @@ typedef struct tagDESKTOP SIZE bitmapSize; BOOL fTileWallPaper; struct tagMONITOR *pPrimaryMonitor; - struct _DESKTOP_DRIVER *pDriver; /* Desktop driver */ + struct tagDESKTOP_DRIVER *pDriver; /* Desktop driver */ void *pDriverData; /* Desktop driver data */ } DESKTOP; -typedef struct _DESKTOP_DRIVER { +typedef struct tagDESKTOP_DRIVER { void (*pInitialize)(struct tagDESKTOP *pDesktop); void (*pFinalize)(struct tagDESKTOP *pDesktop); } DESKTOP_DRIVER; +extern DESKTOP_DRIVER *DESKTOP_Driver; + +extern BOOL DESKTOP_IsSingleWindow(); extern int DESKTOP_GetScreenWidth(void); extern int DESKTOP_GetScreenHeight(void); extern int DESKTOP_GetScreenDepth(void); diff --git a/include/display.h b/include/display.h index 8aa1a113923e3332f3d8f0090487db03e2193262..b5830dd4b53eb7ac56c8ee73169874156e2061d4 100644 --- a/include/display.h +++ b/include/display.h @@ -7,8 +7,9 @@ #ifndef __WINE_DISPLAY_H #define __WINE_DISPLAY_H -#include "cursoricon.h" -#include "wine/winuser16.h" +#include "windef.h" + +struct tagCURSORICONINFO; #pragma pack(1) typedef struct tagCURSORINFO @@ -18,13 +19,8 @@ typedef struct tagCURSORINFO } CURSORINFO, *PCURSORINFO, *LPCURSORINFO; #pragma pack(4) -typedef struct _MOUSE_DRIVER { - VOID (*pSetCursor)(CURSORICONINFO *); - VOID (*pMoveCursor)(WORD, WORD); -} MOUSE_DRIVER; - WORD WINAPI DISPLAY_Inquire(LPCURSORINFO lpCursorInfo); -VOID WINAPI DISPLAY_SetCursor( CURSORICONINFO *lpCursor ); +VOID WINAPI DISPLAY_SetCursor( struct tagCURSORICONINFO *lpCursor ); VOID WINAPI DISPLAY_MoveCursor( WORD wAbsX, WORD wAbsY ); VOID WINAPI DISPLAY_CheckCursor(); diff --git a/include/gdi.h b/include/gdi.h index 7406a32945e02c29d1a84114ff37520e7d4cded4..774cf6819424c01ea751fc60d48bd2e905de26af 100644 --- a/include/gdi.h +++ b/include/gdi.h @@ -70,6 +70,13 @@ typedef struct tagDeviceCaps WORD colorRes; /* 108: color resolution */ } DeviceCaps; +typedef struct tagGDI_DRIVER +{ + BOOL (*pInitialize)(void); + void (*pFinalize)(void); +} GDI_DRIVER; + +extern GDI_DRIVER *GDI_Driver; /* Device independent DC information */ typedef struct @@ -159,6 +166,8 @@ typedef struct tagDC_FUNCS BOOL (*pCreateBitmap)(HBITMAP); BOOL (*pCreateDC)(DC*,LPCSTR,LPCSTR,LPCSTR,const DEVMODE16*); BOOL (*pDeleteDC)(DC*); + HBITMAP (*pCreateDIBSection)(DC *,BITMAPINFO *,UINT,LPVOID *,HANDLE,DWORD); + HBITMAP16 (*pCreateDIBSection16)(DC *,BITMAPINFO *,UINT16,SEGPTR *,HANDLE,DWORD); BOOL (*pDeleteObject)(HGDIOBJ); BOOL (*pEllipse)(DC*,INT,INT,INT,INT); BOOL (*pEnumDeviceFonts)(DC*,LPLOGFONT16,DEVICEFONTENUMPROC,LPARAM); diff --git a/include/keyboard.h b/include/keyboard.h index 8c249bc6a377e8fd2daee2dcc343fa933a26f8c3..1002817b789f4093ac47c44f745bab42f1f21331 100644 --- a/include/keyboard.h +++ b/include/keyboard.h @@ -29,15 +29,22 @@ VOID WINAPI KEYBOARD_Disable(VOID); /* Wine internals */ -typedef struct _KEYBOARD_DRIVER { +typedef struct tagKEYBOARD_DRIVER { void (*pInit)(void); WORD (*pVkKeyScan)(CHAR); UINT16 (*pMapVirtualKey)(UINT16, UINT16); INT16 (*pGetKeyNameText)(LONG, LPSTR, INT16); INT16 (*pToAscii)(UINT16, UINT16, LPBYTE, LPVOID, UINT16); + BOOL (*pGetBeepActive)(void); + void (*pSetBeepActive)(BOOL bActivate); + void (*pBeep)(void); } KEYBOARD_DRIVER; -extern KEYBOARD_DRIVER *KEYBOARD_GetDriver(void); +extern KEYBOARD_DRIVER *KEYBOARD_Driver; + +extern BOOL KEYBOARD_GetBeepActive(void); +extern void KEYBOARD_SetBeepActive(BOOL bActivate); +extern void KEYBOARD_Beep(void); extern void KEYBOARD_SendEvent(BYTE bVk, BYTE bScan, DWORD dwFlags, DWORD posX, DWORD posY, DWORD time); diff --git a/include/message.h b/include/message.h index 6c54bb4b6f0a9bde00309fc025b7d8bb7b6d4d15..ffe942ea406c90b111ce937ed0f91a4a4a87fc27 100644 --- a/include/message.h +++ b/include/message.h @@ -32,21 +32,22 @@ extern BOOL TIMER_GetTimerMsg( MSG *msg, HWND hwnd, #define EVENT_IO_EXCEPT 2 /* event.c */ - -typedef struct _EVENT_DRIVER { - BOOL (*pInit)(void); +typedef struct tagEVENT_DRIVER { + BOOL (*pInit)(void); void (*pAddIO)(int, unsigned); void (*pDeleteIO)(int, unsigned); - BOOL (*pWaitNetEvent)(BOOL, BOOL); + BOOL (*pWaitNetEvent)(BOOL, BOOL); void (*pSynchronize)(void); - BOOL (*pCheckFocus)(void); - BOOL (*pQueryPointer)(DWORD *, DWORD *, DWORD *); + BOOL (*pCheckFocus)(void); + BOOL (*pQueryPointer)(DWORD *, DWORD *, DWORD *); void (*pDummyMotionNotify)(void); - BOOL (*pPending)(void); + BOOL (*pPending)(void); BOOL16 (*pIsUserIdle)(void); void (*pWakeUp)(void); } EVENT_DRIVER; +extern EVENT_DRIVER *EVENT_Driver; + extern void EVENT_AddIO( int fd, unsigned flag ); extern void EVENT_DeleteIO( int fd, unsigned flag ); extern BOOL EVENT_Init( void ); diff --git a/include/monitor.h b/include/monitor.h index ae5f8e106581f54aaeef4146ffd1999bd5a364d5..ec37bbf585426d505da434cfd4bed3b3301373ae 100644 --- a/include/monitor.h +++ b/include/monitor.h @@ -6,28 +6,42 @@ #ifndef __WINE_MONITOR_H #define __WINE_MONITOR_H +#include "windef.h" + struct tagMONITOR_DRIVER; typedef struct tagMONITOR { - struct tagMONITOR_DRIVER *pDriver; - void *pDriverData; + void *pDriverData; } MONITOR; typedef struct tagMONITOR_DRIVER { - void (*pInitialize)(MONITOR *); - void (*pFinalize)(MONITOR *); - int (*pGetWidth)(MONITOR *); - int (*pGetHeight)(MONITOR *); - int (*pGetDepth)(MONITOR *); + void (*pInitialize)(struct tagMONITOR *); + void (*pFinalize)(struct tagMONITOR *); + BOOL (*pIsSingleWindow)(struct tagMONITOR *); + int (*pGetWidth)(struct tagMONITOR *); + int (*pGetHeight)(struct tagMONITOR *); + int (*pGetDepth)(struct tagMONITOR *); + BOOL (*pGetScreenSaveActive)(struct tagMONITOR *); + void (*pSetScreenSaveActive)(struct tagMONITOR *, BOOL); + int (*pGetScreenSaveTimeout)(struct tagMONITOR *); + void (*pSetScreenSaveTimeout)(struct tagMONITOR *, int); } MONITOR_DRIVER; +extern MONITOR_DRIVER *MONITOR_Driver; + extern MONITOR MONITOR_PrimaryMonitor; extern void MONITOR_Initialize(MONITOR *pMonitor); extern void MONITOR_Finalize(MONITOR *pMonitor); +extern BOOL MONITOR_IsSingleWindow(MONITOR *pMonitor); extern int MONITOR_GetWidth(MONITOR *pMonitor); extern int MONITOR_GetHeight(MONITOR *pMonitor); extern int MONITOR_GetDepth(MONITOR *pMonitor); +extern BOOL MONITOR_GetScreenSaveActive(MONITOR *pMonitor); +extern void MONITOR_SetScreenSaveActive(MONITOR *pMonitor, BOOL bActivate); +extern int MONITOR_GetScreenSaveTimeout(MONITOR *pMonitor); +extern void MONITOR_SetScreenSaveTimeout(MONITOR *pMonitor, int nTimeout); #endif /* __WINE_MONITOR_H */ + diff --git a/include/mouse.h b/include/mouse.h index 1de96ddddc3524c7c87d79de453b5c711da5d23d..2b7d18da8d0a85a5aeafd5f9353ede083ceaf8d2 100644 --- a/include/mouse.h +++ b/include/mouse.h @@ -7,6 +7,10 @@ #ifndef __WINE_MOUSE_H #define __WINE_MOUSE_H +#include "windef.h" + +struct tagCURSORICONINFO; + #pragma pack(1) typedef struct _MOUSEINFO { @@ -30,6 +34,14 @@ VOID WINAPI MOUSE_Disable(VOID); /* Wine internals */ +typedef struct tagMOUSE_DRIVER { + VOID (*pSetCursor)(struct tagCURSORICONINFO *); + VOID (*pMoveCursor)(WORD, WORD); + BOOL (*pEnableWarpPointer)(BOOL); +} MOUSE_DRIVER; + +extern MOUSE_DRIVER *MOUSE_Driver; + #define WINE_MOUSEEVENT_MAGIC ( ('M'<<24)|('A'<<16)|('U'<<8)|'S' ) typedef struct _WINE_MOUSEEVENT { diff --git a/include/palette.h b/include/palette.h index c6e4cfb8c42a5cd8ff46752846c1226b17551ca0..a7011f1ad4c4949b366da049edb3daed6feaafe6 100644 --- a/include/palette.h +++ b/include/palette.h @@ -12,13 +12,22 @@ #define NB_RESERVED_COLORS 20 /* number of fixed colors in system palette */ /* GDI logical palette object */ -typedef struct +typedef struct tagPALETTEOBJ { - GDIOBJHDR header; - int *mapping; - LOGPALETTE logpalette; /* _MUST_ be the last field */ + GDIOBJHDR header; + int *mapping; + LOGPALETTE logpalette; /* _MUST_ be the last field */ } PALETTEOBJ; +typedef struct tagPALETTE_DRIVER +{ + int (*pSetMapping)(struct tagPALETTEOBJ *, UINT, UINT, BOOL); + int (*pUpdateMapping)(struct tagPALETTEOBJ *); + BOOL (*pIsDark)(int pixel); +} PALETTE_DRIVER; + +extern PALETTE_DRIVER *PALETTE_Driver; + extern HPALETTE16 PALETTE_Init(void); extern int PALETTE_GetObject( PALETTEOBJ * palette, int count, LPSTR buffer ); extern BOOL PALETTE_DeleteObject( HPALETTE16 hpalette, PALETTEOBJ *palette ); diff --git a/include/sysmetrics.h b/include/sysmetrics.h index 376528a9aa44f46a09455da9791d36cdcd6a1829..811e6ac164b643722c569e5c0e82cfc737b6fbc5 100644 --- a/include/sysmetrics.h +++ b/include/sysmetrics.h @@ -7,7 +7,8 @@ #ifndef __WINE_SYSMETRICS_H #define __WINE_SYSMETRICS_H -#include "windef.h" +#include "wingdi.h" + /* Constant system metrics */ #if 0 #ifdef WIN_95_LOOK diff --git a/include/ttydrv.h b/include/ttydrv.h index abef5bce60fbcc45d1a9ce1986fe79e2dce3c34f..d66997f442bc2a259b2eebe12502166ea78b17d1 100644 --- a/include/ttydrv.h +++ b/include/ttydrv.h @@ -6,27 +6,67 @@ #define __WINE_TTYDRV_H #include "windef.h" +#include "wingdi.h" #include "wine/winuser16.h" +struct tagBITMAPOBJ; struct tagCLASS; struct tagDC; struct tagDESKTOP; +struct tagPALETTEOBJ; struct tagWND; -/* TTY GDI driver */ +/************************************************************************** + * TTY GDI driver + */ + +extern struct tagGDI_DRIVER TTYDRV_GDI_Driver; + +extern BOOL TTYDRV_GDI_Initialize(void); +extern void TTYDRV_GDI_Finalize(void); + +/* TTY GDI bitmap driver */ + +extern HBITMAP TTYDRV_BITMAP_CreateDIBSection(struct tagDC *dc, BITMAPINFO *bmi, UINT usage, LPVOID *bits, HANDLE section, DWORD offset); +extern HBITMAP16 TTYDRV_BITMAP_CreateDIBSection16(struct tagDC *dc, BITMAPINFO *bmi, UINT16 usage, SEGPTR *bits, HANDLE section, DWORD offset); + +extern INT TTYDRV_BITMAP_SetDIBits(struct tagBITMAPOBJ *bmp, struct tagDC *dc, UINT startscan, UINT lines, LPCVOID bits, const BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap); +extern INT TTYDRV_BITMAP_GetDIBits(struct tagBITMAPOBJ *bmp, struct tagDC *dc, UINT startscan, UINT lines, LPVOID bits, BITMAPINFO *info, UINT coloruse, HBITMAP hbitmap); +extern void TTYDRV_BITMAP_DeleteDIBSection(struct tagBITMAPOBJ *bmp); typedef struct { + int dummy; } TTYDRV_PDEVICE; -extern BOOL TTYDRV_GDI_Initialize(void); -extern void TTDRV_GDI_Finalize(void); -extern BOOL TTYDRV_GDI_CreateDC(struct tagDC *dc, LPCSTR driver, LPCSTR device, LPCSTR output, const DEVMODE16 *initData); -extern BOOL TTYDRV_GDI_DeleteDC(struct tagDC *dc); -extern INT TTYDRV_GDI_Escape(struct tagDC *dc, INT nEscape, INT cbInput, SEGPTR lpInData, SEGPTR lpOutData); +extern BOOL TTYDRV_DC_CreateDC(struct tagDC *dc, LPCSTR driver, LPCSTR device, LPCSTR output, const DEVMODE16 *initData); +extern BOOL TTYDRV_DC_DeleteDC(struct tagDC *dc); +extern INT TTYDRV_DC_Escape(struct tagDC *dc, INT nEscape, INT cbInput, SEGPTR lpInData, SEGPTR lpOutData); + +/* TTY GDI palette driver */ + +extern struct tagPALETTE_DRIVER TTYDRV_PALETTE_Driver; + +extern BOOL TTYDRV_PALETTE_Initialize(void); +extern void TTYDRV_PALETTE_Finalize(void); + +extern int TTYDRV_PALETTE_SetMapping(struct tagPALETTEOBJ *palPtr, UINT uStart, UINT uNum, BOOL mapOnly); +extern int TTYDRV_PALETTE_UpdateMapping(struct tagPALETTEOBJ *palPtr); +extern BOOL TTYDRV_PALETTE_IsDark(int pixel); + +/************************************************************************** + * TTY USER driver + */ + +extern struct tagUSER_DRIVER TTYDRV_USER_Driver; + +extern BOOL TTYDRV_USER_Initialize(void); +extern void TTYDRV_USER_Finalize(void); +extern void TTYDRV_USER_BeginDebugging(void); +extern void TTYDRV_USER_EndDebugging(void); /* TTY clipboard driver */ -extern struct _CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver; +extern struct tagCLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver; extern void TTYDRV_CLIPBOARD_EmptyClipboard(void); extern void TTYDRV_CLIPBOARD_SetClipboardData(UINT wFormat); @@ -35,7 +75,7 @@ extern void TTYDRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar); /* TTY desktop driver */ -extern struct _DESKTOP_DRIVER TTYDRV_DESKTOP_Driver; +extern struct tagDESKTOP_DRIVER TTYDRV_DESKTOP_Driver; extern void TTYDRV_DESKTOP_Initialize(struct tagDESKTOP *pDesktop); extern void TTYDRV_DESKTOP_Finalize(struct tagDESKTOP *pDesktop); @@ -45,7 +85,7 @@ extern int TTYDRV_DESKTOP_GetScreenDepth(struct tagDESKTOP *pDesktop); /* TTY event driver */ -extern struct _EVENT_DRIVER TTYDRV_EVENT_Driver; +extern struct tagEVENT_DRIVER TTYDRV_EVENT_Driver; extern BOOL TTYDRV_EVENT_Init(void); extern void TTYDRV_EVENT_AddIO(int fd, unsigned flag); @@ -61,22 +101,16 @@ extern void TTYDRV_EVENT_WakeUp(void); /* TTY keyboard driver */ -extern struct _KEYBOARD_DRIVER TTYDRV_KEYBOARD_Driver; +extern struct tagKEYBOARD_DRIVER TTYDRV_KEYBOARD_Driver; extern void TTYDRV_KEYBOARD_Init(void); extern WORD TTYDRV_KEYBOARD_VkKeyScan(CHAR cChar); extern UINT16 TTYDRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType); extern INT16 TTYDRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize); extern INT16 TTYDRV_KEYBOARD_ToAscii(UINT16 virtKey, UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags); - -/* TTY main driver */ - -extern void TTYDRV_MAIN_Finalize(void); -extern void TTYDRV_MAIN_Initialize(void); -extern void TTYDRV_MAIN_ParseOptions(int *argc, char *argv[]); -extern void TTYDRV_MAIN_Create(void); -extern void TTYDRV_MAIN_SaveSetup(void); -extern void TTYDRV_MAIN_RestoreSetup(void); +extern BOOL TTYDRV_KEYBOARD_GetBeepActive(void); +extern void TTYDRV_KEYBOARD_SetBeepActive(BOOL bActivate); +extern void TTYDRV_KEYBOARD_Beep(void); /* TTY monitor driver */ @@ -92,20 +126,26 @@ struct tagMONITOR; extern void TTYDRV_MONITOR_Initialize(struct tagMONITOR *pMonitor); extern void TTYDRV_MONITOR_Finalize(struct tagMONITOR *pMonitor); +extern BOOL TTYDRV_MONITOR_IsSingleWindow(struct tagMONITOR *pMonitor); extern int TTYDRV_MONITOR_GetWidth(struct tagMONITOR *pMonitor); extern int TTYDRV_MONITOR_GetHeight(struct tagMONITOR *pMonitor); extern int TTYDRV_MONITOR_GetDepth(struct tagMONITOR *pMonitor); +extern BOOL TTYDRV_MONITOR_GetScreenSaveActive(struct tagMONITOR *pMonitor); +extern void TTYDRV_MONITOR_SetScreenSaveActive(struct tagMONITOR *pMonitor, BOOL bActivate); +extern int TTYDRV_MONITOR_GetScreenSaveTimeout(struct tagMONITOR *pMonitor); +extern void TTYDRV_MONITOR_SetScreenSaveTimeout(struct tagMONITOR *pMonitor, int nTimeout); /* TTY mouse driver */ -extern struct _MOUSE_DRIVER TTYDRV_MOUSE_Driver; +extern struct tagMOUSE_DRIVER TTYDRV_MOUSE_Driver; extern void TTYDRV_MOUSE_SetCursor(CURSORICONINFO *lpCursor); extern void TTYDRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY); +extern BOOL TTYDRV_MOUSE_EnableWarpPointer(BOOL bEnable); /* TTY windows driver */ -extern struct _WND_DRIVER TTYDRV_WND_Driver; +extern struct tagWND_DRIVER TTYDRV_WND_Driver; extern void TTYDRV_WND_Initialize(struct tagWND *wndPtr); extern void TTYDRV_WND_Finalize(struct tagWND *wndPtr); diff --git a/include/user.h b/include/user.h index 2e9923c1222359c8112eee0123c23774e9657821..f7ab2ba7c256f65dc740598e046bbfa2944da44c 100644 --- a/include/user.h +++ b/include/user.h @@ -29,6 +29,15 @@ extern WORD USER_HeapSel; #define USUD_LOCALHEAP 0x0004 #define USUD_FIRSTCLASS 0x0005 +typedef struct tagUSER_DRIVER { + BOOL (*pInitialize)(void); + void (*pFinalize)(void); + void (*pBeginDebugging)(void); + void (*pEndDebugging)(void); +} USER_DRIVER; + +extern USER_DRIVER *USER_Driver; + void WINAPI USER_SignalProc(HANDLE16, UINT16, UINT16, HINSTANCE16, HQUEUE16); void USER_ExitWindows(void); void USER_QueueCleanup( HQUEUE16 hQueue ); diff --git a/include/win.h b/include/win.h index 5d166842838d9fef2ca511522b4a6e6efc7d97e7..1c37a53716203302352ab9d1fc884d6a929020bb 100644 --- a/include/win.h +++ b/include/win.h @@ -52,7 +52,7 @@ typedef enum struct tagCLASS; struct tagDCE; struct tagDC; -struct _WND_DRIVER; +struct tagWND_DRIVER; typedef struct tagWND { @@ -83,7 +83,7 @@ typedef struct tagWND HMENU16 hSysMenu; /* window's copy of System Menu */ int irefCount; /* window's reference count*/ DWORD userdata; /* User private data */ - struct _WND_DRIVER *pDriver; /* Window driver */ + struct tagWND_DRIVER *pDriver; /* Window driver */ void *pDriverData; /* Window driver data */ DWORD wExtra[1]; /* Window extra bytes */ } WND; @@ -107,7 +107,7 @@ typedef struct tagWND #define BGSouthEast 9 #define BGStatic 10 -typedef struct _WND_DRIVER +typedef struct tagWND_DRIVER { void (*pInitialize)(WND *); void (*pFinalize)(WND *); @@ -127,6 +127,8 @@ typedef struct _WND_DRIVER BOOL (*pIsSelfClipping)(WND *); } WND_DRIVER; +extern WND_DRIVER *WND_Driver; + typedef struct { RECT16 rectNormal; diff --git a/include/x11drv.h b/include/x11drv.h index deb92705b3d2f8f62f7b75b945886a559da08a85..4b9a9676d7aa6fba27f577b27677bbcf16ca114b 100644 --- a/include/x11drv.h +++ b/include/x11drv.h @@ -1,5 +1,5 @@ /* - * X11 display driver definitions + * X11 driver definitions */ #ifndef __WINE_X11DRV_H @@ -18,13 +18,15 @@ #include "gdi.h" #include "windef.h" +struct tagBITMAPOBJ; struct tagCLASS; +struct tagCREATESTRUCTA; +struct tagCURSORICONINFO; struct tagDC; struct tagDeviceCaps; +struct tagPALETTEOBJ; struct tagWND; -struct tagCREATESTRUCTA; struct tagWINDOWPOS; -struct tagCURSORICONINFO; /* X physical pen */ typedef struct @@ -74,6 +76,7 @@ extern GC BITMAP_monoGC, BITMAP_colorGC; #define BITMAP_GC(bmp) \ (((bmp)->bitmap.bmBitsPixel == 1) ? BITMAP_monoGC : BITMAP_colorGC) +extern DeviceCaps X11DRV_DevCaps; /* Wine driver X11 functions */ @@ -188,6 +191,26 @@ extern void _XInitImageFuncPtrs(XImage *); /* exported dib functions for now */ +/* Additional info for DIB section objects */ +typedef struct +{ + /* Windows DIB section */ + DIBSECTION dibSection; + + /* Mapping status */ + enum { X11DRV_DIB_NoHandler, X11DRV_DIB_InSync, X11DRV_DIB_AppMod, X11DRV_DIB_GdiMod } status; + + /* Color map info */ + int nColorMap; + int *colorMap; + + /* Cached XImage */ + XImage *image; + + /* Selector for 16-bit access to bits */ + WORD selector; +} X11DRV_DIBSECTION; + /* This structure holds the arguments for DIB_SetImageBits() */ typedef struct { @@ -209,17 +232,86 @@ typedef struct int yDest; int width; int height; -} DIB_SETIMAGEBITS_DESCR; +} X11DRV_DIB_SETIMAGEBITS_DESCR; -extern int X11DRV_DIB_GetImageBits( const DIB_SETIMAGEBITS_DESCR *descr ); -extern int X11DRV_DIB_SetImageBits( const DIB_SETIMAGEBITS_DESCR *descr ); +extern int X11DRV_DIB_GetImageBits( const X11DRV_DIB_SETIMAGEBITS_DESCR *descr ); +extern int X11DRV_DIB_SetImageBits( const X11DRV_DIB_SETIMAGEBITS_DESCR *descr ); extern int *X11DRV_DIB_BuildColorMap( struct tagDC *dc, WORD coloruse, WORD depth, const BITMAPINFO *info, int *nColors ); +extern void X11DRV_DIB_UpdateDIBSection(struct tagDC *dc, BOOL toDIB); + +extern HBITMAP X11DRV_DIB_CreateDIBSection(struct tagDC *dc, BITMAPINFO *bmi, UINT usage, + LPVOID *bits, HANDLE section, DWORD offset); +extern HBITMAP16 X11DRV_DIB_CreateDIBSection16(struct tagDC *dc, BITMAPINFO *bmi, UINT16 usage, + SEGPTR *bits, HANDLE section, DWORD offset); + +extern struct tagBITMAP_DRIVER X11DRV_BITMAP_Driver; + +extern INT X11DRV_DIB_SetDIBits(struct tagBITMAPOBJ *bmp, struct tagDC *dc, UINT startscan, + UINT lines, LPCVOID bits, const BITMAPINFO *info, + UINT coloruse, HBITMAP hbitmap); +extern INT X11DRV_DIB_GetDIBits(struct tagBITMAPOBJ *bmp, struct tagDC *dc, UINT startscan, + UINT lines, LPVOID bits, BITMAPINFO *info, + UINT coloruse, HBITMAP hbitmap); +extern void X11DRV_DIB_DeleteDIBSection(struct tagBITMAPOBJ *bmp); + +/************************************************************************** + * X11 GDI driver + */ + +extern struct tagGDI_DRIVER X11DRV_GDI_Driver; + +BOOL X11DRV_GDI_Initialize(void); +void X11DRV_GDI_Finalize(void); + +/* X11 GDI palette driver */ + +#define X11DRV_PALETTE_FIXED 0x0001 /* read-only colormap - have to use XAllocColor (if not virtual)*/ +#define X11DRV_PALETTE_VIRTUAL 0x0002 /* no mapping needed - pixel == pixel color */ + +#define X11DRV_PALETTE_PRIVATE 0x1000 /* private colormap, identity mapping */ +#define X11DRV_PALETTE_WHITESET 0x2000 + +extern Colormap X11DRV_PALETTE_PaletteXColormap; +extern UINT16 X11DRV_PALETTE_PaletteFlags; + +extern int *X11DRV_PALETTE_PaletteToXPixel; +extern int *X11DRV_PALETTE_XPixelToPalette; + +extern int X11DRV_PALETTE_mapEGAPixel[16]; + +extern BOOL X11DRV_PALETTE_Init(void); +extern void X11DRV_PALETTE_Cleanup(void); + +extern COLORREF X11DRV_PALETTE_ToLogical(int pixel); +extern int X11DRV_PALETTE_ToPhysical(struct tagDC *dc, COLORREF color); +extern int X11DRV_PALETTE_LookupSystemXPixel(COLORREF col); + +extern struct tagPALETTE_DRIVER X11DRV_PALETTE_Driver; + +extern int X11DRV_PALETTE_SetMapping(struct tagPALETTEOBJ *palPtr, UINT uStart, UINT uNum, BOOL mapOnly); +extern int X11DRV_PALETTE_UpdateMapping(struct tagPALETTEOBJ *palPtr); +extern BOOL X11DRV_PALETTE_IsDark(int pixel); + +/************************************************************************** + * X11 USER driver + */ + +extern struct tagUSER_DRIVER X11DRV_USER_Driver; + +extern Display *display; +extern Screen *X11DRV_GetXScreen(void); +extern Window X11DRV_GetXRootWindow(void); + +extern BOOL X11DRV_USER_Initialize(void); +extern void X11DRV_USER_Finalize(void); +extern void X11DRV_USER_BeginDebugging(void); +extern void X11DRV_USER_EndDebugging(void); /* X11 clipboard driver */ -extern struct _CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver; +extern struct tagCLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver; extern void X11DRV_CLIPBOARD_EmptyClipboard(void); extern void X11DRV_CLIPBOARD_SetClipboardData(UINT wFormat); @@ -229,15 +321,12 @@ extern void X11DRV_CLIPBOARD_ResetOwner(struct tagWND *pWnd, BOOL bFooBar); void X11DRV_CLIPBOARD_ReadSelection(Window w, Atom prop); void X11DRV_CLIPBOARD_ReleaseSelection(Window w, HWND hwnd); -/* X11 color driver */ - -extern Colormap X11DRV_COLOR_GetColormap(void); - /* X11 desktop driver */ -extern struct _DESKTOP_DRIVER X11DRV_DESKTOP_Driver; +extern struct tagDESKTOP_DRIVER X11DRV_DESKTOP_Driver; typedef struct _X11DRV_DESKTOP_DATA { + int dummy; } X11DRV_DESKTOP_DATA; struct tagDESKTOP; @@ -253,7 +342,7 @@ extern int X11DRV_DESKTOP_GetScreenDepth(struct tagDESKTOP *pDesktop); /* X11 event driver */ -extern struct _EVENT_DRIVER X11DRV_EVENT_Driver; +extern struct tagEVENT_DRIVER X11DRV_EVENT_Driver; extern BOOL X11DRV_EVENT_Init(void); extern void X11DRV_EVENT_AddIO(int fd, unsigned flag); @@ -269,28 +358,18 @@ extern void X11DRV_EVENT_WakeUp(void); /* X11 keyboard driver */ -extern struct _KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver; +extern struct tagKEYBOARD_DRIVER X11DRV_KEYBOARD_Driver; extern void X11DRV_KEYBOARD_Init(void); extern WORD X11DRV_KEYBOARD_VkKeyScan(CHAR cChar); extern UINT16 X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode, UINT16 wMapType); extern INT16 X11DRV_KEYBOARD_GetKeyNameText(LONG lParam, LPSTR lpBuffer, INT16 nSize); extern INT16 X11DRV_KEYBOARD_ToAscii(UINT16 virtKey, UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags); -extern void KEYBOARD_HandleEvent( struct tagWND *pWnd, XKeyEvent *event ); -extern void KEYBOARD_UpdateState ( void ); +extern BOOL X11DRV_KEYBOARD_GetBeepActive(void); +extern void X11DRV_KEYBOARD_SetBeepActive(BOOL bActivate); +extern void X11DRV_KEYBOARD_Beep(void); -/* X11 main driver */ - -extern Display *display; -extern Screen *X11DRV_GetXScreen(void); -extern Window X11DRV_GetXRootWindow(void); - -extern void X11DRV_MAIN_Finalize(void); -extern void X11DRV_MAIN_Initialize(void); -extern void X11DRV_MAIN_ParseOptions(int *argc, char *argv[]); -extern void X11DRV_MAIN_Create(void); -extern void X11DRV_MAIN_SaveSetup(void); -extern void X11DRV_MAIN_RestoreSetup(void); +extern void X11DRV_KEYBOARD_HandleEvent(struct tagWND *pWnd, XKeyEvent *event); /* X11 monitor driver */ @@ -311,20 +390,28 @@ extern Window X11DRV_MONITOR_GetXRootWindow(struct tagMONITOR *pMonitor); extern void X11DRV_MONITOR_Initialize(struct tagMONITOR *pMonitor); extern void X11DRV_MONITOR_Finalize(struct tagMONITOR *pMonitor); +extern BOOL X11DRV_MONITOR_IsSingleWindow(struct tagMONITOR *pMonitor); extern int X11DRV_MONITOR_GetWidth(struct tagMONITOR *pMonitor); extern int X11DRV_MONITOR_GetHeight(struct tagMONITOR *pMonitor); extern int X11DRV_MONITOR_GetDepth(struct tagMONITOR *pMonitor); +extern BOOL X11DRV_MONITOR_GetScreenSaveActive(struct tagMONITOR *pMonitor); +extern void X11DRV_MONITOR_SetScreenSaveActive(struct tagMONITOR *pMonitor, BOOL bActivate); +extern int X11DRV_MONITOR_GetScreenSaveTimeout(struct tagMONITOR *pMonitor); +extern void X11DRV_MONITOR_SetScreenSaveTimeout(struct tagMONITOR *pMonitor, int nTimeout); /* X11 mouse driver */ -extern struct _MOUSE_DRIVER X11DRV_MOUSE_Driver; +extern struct tagMOUSE_DRIVER X11DRV_MOUSE_Driver; + +extern BOOL X11DRV_MOUSE_DisableWarpPointer; extern void X11DRV_MOUSE_SetCursor(struct tagCURSORICONINFO *lpCursor); extern void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY); +extern BOOL X11DRV_MOUSE_EnableWarpPointer(BOOL bEnable); /* X11 windows driver */ -extern struct _WND_DRIVER X11DRV_WND_Driver; +extern struct tagWND_DRIVER X11DRV_WND_Driver; typedef struct _X11DRV_WND_DATA { Window window; diff --git a/misc/main.c b/misc/main.c index a09b751a9c95be75ca70faad4faec806d00f1e4b..e759b7c0c1d98ac541f67dbea2237341c6aff865 100644 --- a/misc/main.c +++ b/misc/main.c @@ -7,11 +7,10 @@ #include "config.h" #ifndef X_DISPLAY_MISSING -#include "ts_xlib.h" #include "x11drv.h" -#else /* X_DISPLAY_MISSING */ +#else /* !defined(X_DISPLAY_MISSING) */ #include "ttydrv.h" -#endif /* X_DISPLAY_MISSING */ +#endif /* !defined(X_DISPLAY_MISSING) */ #include <locale.h> #include <ctype.h> @@ -21,7 +20,7 @@ #ifdef MALLOC_DEBUGGING # include <malloc.h> #endif -#include "wine/winuser16.h" + #include "winbase.h" #include "winsock.h" #include "heap.h" @@ -39,6 +38,14 @@ #include "winnls.h" #include "console.h" #include "monitor.h" +#include "keyboard.h" +#include "gdi.h" +#include "user.h" +#include "wine/winuser16.h" + +/**********************************************************************/ + +USER_DRIVER *USER_Driver = NULL; /* when adding new languages look at ole/ole2nls.c * for proper iso name and Windows code (add 0x0400 @@ -100,7 +107,6 @@ struct options Options = static char szUsage[] = "%s\n" "Usage: %s [options] \"program_name [arguments]\"\n" -#ifndef X_DISPLAY_MISSING "\n" "Options:\n" " -backingstore Turn on backing store\n" @@ -128,7 +134,6 @@ static char szUsage[] = " -version Display the Wine version\n" " -winver Version to imitate (one of win31,win95,nt351,nt40)\n" " -dosver DOS version to imitate (x.xx, e.g. 6.22). Only valid with -winver win31\n" -#endif /* X_DISPLAY_MISSING */ ; /*********************************************************************** @@ -744,12 +749,6 @@ static void MAIN_ParseOptions( int *argc, char *argv[] ) exit(0); } } - -#ifndef X_DISPLAY_MISSING - X11DRV_MAIN_ParseOptions(argc,argv); -#else /* X_DISPLAY_MISSING */ - TTYDRV_MAIN_ParseOptions(argc,argv); -#endif /* X_DISPLAY_MISSING */ } /*********************************************************************** @@ -757,12 +756,9 @@ static void MAIN_ParseOptions( int *argc, char *argv[] ) */ static void called_at_exit(void) { -#ifndef X_DISPLAY_MISSING - X11DRV_MAIN_RestoreSetup(); -#else /* X_DISPLAY_MISSING */ - TTYDRV_MAIN_RestoreSetup(); -#endif /* X_DISPLAY_MISSING */ - COLOR_Cleanup(); + GDI_Driver->pFinalize(); + USER_Driver->pFinalize(); + WINSOCK_Shutdown(); CONSOLE_Close(); } @@ -798,23 +794,16 @@ BOOL MAIN_WineInit( int *argc, char *argv[] ) gettimeofday( &tv, NULL); MSG_WineStartTicks = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); -#ifndef X_DISPLAY_MISSING - X11DRV_MAIN_Initialize(); - MAIN_ParseOptions( argc, argv ); - X11DRV_MAIN_Create(); - X11DRV_MAIN_SaveSetup(); -#else /* !defined(X_DISPLAY_MISSING) */ - TTYDRV_MAIN_Initialize(); - MAIN_ParseOptions( argc, argv ); - TTYDRV_MAIN_Create(); - TTYDRV_MAIN_SaveSetup(); -#endif /* !defined(X_DISPLAY_MISSING) */ + MAIN_ParseOptions(argc, argv); #ifndef X_DISPLAY_MISSING - MONITOR_PrimaryMonitor.pDriver = &X11DRV_MONITOR_Driver; + USER_Driver = &X11DRV_USER_Driver; #else /* !defined(X_DISPLAY_MISSING) */ - MONITOR_PrimaryMonitor.pDriver = &TTYDRV_MONITOR_Driver; + USER_Driver = &TTYDRV_USER_Driver; #endif /* !defined(X_DISPLAY_MISSING) */ + + USER_Driver->pInitialize(); + MONITOR_Initialize(&MONITOR_PrimaryMonitor); if (Options.dllFlags) @@ -839,7 +828,7 @@ void WINAPI MessageBeep16( UINT16 i ) */ BOOL WINAPI MessageBeep( UINT i ) { - TSXBell( display, 0 ); + KEYBOARD_Beep(); return TRUE; } @@ -850,7 +839,7 @@ BOOL WINAPI MessageBeep( UINT i ) BOOL WINAPI Beep( DWORD dwFreq, DWORD dwDur ) { /* dwFreq and dwDur are ignored by Win95 */ - TSXBell(display, 0); + KEYBOARD_Beep(); return TRUE; } @@ -870,17 +859,14 @@ BOOL WINAPI SystemParametersInfoA( UINT uAction, UINT uParam, LPVOID lpvParam, UINT fuWinIni ) { int timeout; - int temp; - XKeyboardState keyboard_state; switch (uAction) { case SPI_GETBEEP: - TSXGetKeyboardControl(display, &keyboard_state); - if (keyboard_state.bell_percent == 0) - *(BOOL *) lpvParam = FALSE; - else - *(BOOL *) lpvParam = TRUE; + *(BOOL *) lpvParam = KEYBOARD_GetBeepActive(); break; + case SPI_SETBEEP: + KEYBOARD_SetBeepActive(uParam); + break; case SPI_GETBORDER: *(INT *)lpvParam = GetSystemMetrics( SM_CXFRAME ); @@ -920,19 +906,18 @@ BOOL WINAPI SystemParametersInfoA( UINT uAction, UINT uParam, *(BOOL*)lpvParam=GetSystemMetrics(SM_MENUDROPALIGNMENT); /* XXX check this */ break; - case SPI_GETSCREENSAVEACTIVE: - if ( GetProfileIntA( "windows", "ScreenSaveActive", 1 ) == 1 ) - *(BOOL*)lpvParam = TRUE; + case SPI_GETSCREENSAVEACTIVE: + if(MONITOR_GetScreenSaveActive(&MONITOR_PrimaryMonitor) || + GetProfileIntA( "windows", "ScreenSaveActive", 1 ) == 1) + *(BOOL*)lpvParam = TRUE; else *(BOOL*)lpvParam = FALSE; break; case SPI_GETSCREENSAVETIMEOUT: -#ifndef X_DISPLAY_MISSING - TSXGetScreenSaver(display, &timeout, &temp,&temp,&temp); -#else /* X_DISPLAY_MISSING */ - timeout = GetProfileIntA( "windows", "ScreenSaveTimeout", 300 ); -#endif /* X_DISPLAY_MISSING */ + timeout = MONITOR_GetScreenSaveTimeout(&MONITOR_PrimaryMonitor); + if(!timeout) + timeout = GetProfileIntA( "windows", "ScreenSaveTimeout", 300 ); *(INT *) lpvParam = timeout * 1000; break; @@ -1056,18 +1041,11 @@ BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam, { int timeout; char buffer[256]; - int temp; - XKeyboardState keyboard_state; - XKeyboardControl keyboard_value; switch (uAction) { case SPI_GETBEEP: - TSXGetKeyboardControl(display, &keyboard_state); - if (keyboard_state.bell_percent == 0) - *(BOOL16 *) lpvParam = FALSE; - else - *(BOOL16 *) lpvParam = TRUE; + *(BOOL *) lpvParam = KEYBOARD_GetBeepActive(); break; case SPI_GETBORDER: @@ -1109,18 +1087,17 @@ BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam, break; case SPI_GETSCREENSAVEACTIVE: - if ( GetProfileIntA( "windows", "ScreenSaveActive", 1 ) == 1 ) - *(BOOL16 *) lpvParam = TRUE; + if(MONITOR_GetScreenSaveActive(&MONITOR_PrimaryMonitor) || + GetProfileIntA( "windows", "ScreenSaveActive", 1 ) == 1) + *(BOOL16 *) lpvParam = TRUE; else *(BOOL16 *) lpvParam = FALSE; break; case SPI_GETSCREENSAVETIMEOUT: -#ifndef X_DISPLAY_MISSING - TSXGetScreenSaver(display, &timeout, &temp,&temp,&temp); -#else /* X_DISPLAY_MISSING */ - timeout = GetProfileIntA( "windows", "ScreenSaveTimeout", 300 ); -#endif /* X_DISPLAY_MISSING */ + timeout = MONITOR_GetScreenSaveTimeout(&MONITOR_PrimaryMonitor); + if(!timeout) + timeout = GetProfileIntA( "windows", "ScreenSaveTimeout", 300 ); *(INT16 *) lpvParam = timeout; break; @@ -1141,24 +1118,15 @@ BOOL16 WINAPI SystemParametersInfo16( UINT16 uAction, UINT16 uParam, break; case SPI_SETBEEP: - if (uParam == TRUE) - keyboard_value.bell_percent = -1; - else - keyboard_value.bell_percent = 0; - TSXChangeKeyboardControl(display, KBBellPercent, - &keyboard_value); + KEYBOARD_SetBeepActive(uParam); break; case SPI_SETSCREENSAVEACTIVE: - if (uParam == TRUE) - TSXActivateScreenSaver(display); - else - TSXResetScreenSaver(display); + MONITOR_SetScreenSaveActive(&MONITOR_PrimaryMonitor, uParam); break; case SPI_SETSCREENSAVETIMEOUT: - TSXSetScreenSaver(display, uParam, 60, DefaultBlanking, - DefaultExposures); + MONITOR_SetScreenSaveTimeout(&MONITOR_PrimaryMonitor, uParam); break; case SPI_SETDESKWALLPAPER: diff --git a/objects/bitmap.c b/objects/bitmap.c index bb38dd3eee0d0c56d64dc1398930cbf58ebb797c..f3d90895366d0010055e71b67eed36dc2807cbd1 100644 --- a/objects/bitmap.c +++ b/objects/bitmap.c @@ -20,6 +20,50 @@ #include "monitor.h" #include "wine/winuser16.h" +/**********************************************************************/ + +BITMAP_DRIVER *BITMAP_Driver = NULL; + +/*********************************************************************** + * BITMAP_GetPadding + * + * Return number of bytes to pad a scanline of 16-bit aligned Windows DDB data. + */ +INT BITMAP_GetPadding( int bmWidth, int bpp ) +{ + INT pad; + + switch (bpp) + { + case 1: + pad = ((bmWidth-1) & 8) ? 0 : 1; + break; + + case 8: + pad = (2 - (bmWidth & 1)) & 1; + break; + + case 24: + pad = (bmWidth*3) & 1; + break; + + case 32: + case 16: + case 15: + pad = 0; /* we have 16bit alignment already */ + break; + + case 4: + if (!(bmWidth & 3)) pad = 0; + else pad = ((4 - (bmWidth & 3)) + 1) / 2; + break; + + default: + WARN(bitmap,"Unknown depth %d, please report.\n", bpp ); + return -1; + } + return pad; +} /*********************************************************************** * BITMAP_GetWidthBytes @@ -717,7 +761,7 @@ INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer ) { if ( count <= sizeof(BITMAP16) ) { - BITMAP *bmp32 = &bmp->dib->dibSection.dsBm; + BITMAP *bmp32 = &bmp->dib->dsBm; BITMAP16 bmp16; bmp16.bmType = bmp32->bmType; bmp16.bmWidth = bmp32->bmWidth; @@ -768,7 +812,7 @@ INT BITMAP_GetObject( BITMAPOBJ * bmp, INT count, LPVOID buffer ) if (count > sizeof(DIBSECTION)) count = sizeof(DIBSECTION); } - memcpy( buffer, &bmp->dib->dibSection, count ); + memcpy( buffer, bmp->dib, count ); return count; } else diff --git a/objects/color.c b/objects/color.c index 3a47a385d42d92fa6c92b91f3c69b7663aaaee1f..e074faac0b8a1d52dacddefd09ab37985eda5334 100644 --- a/objects/color.c +++ b/objects/color.c @@ -5,85 +5,28 @@ * Copyright 1996 Alex Korobka */ -#include "ts_xlib.h" -#include "x11drv.h" - -#include <stdlib.h> -#include <string.h> -#include "windef.h" -#include "options.h" -#include "gdi.h" #include "color.h" #include "debug.h" -#include "xmalloc.h" -#include "monitor.h" - -/* Palette indexed mode: - - * logical palette -> mapping -> pixel - * - * - * Windows needs contiguous color space ( from 0 to n ) but - * it is possible only with the private colormap. Otherwise we - * have to map DC palette indices to real pixel values. With - * private colormaps it boils down to the identity mapping. The - * other special case is when we have a fixed color visual with - * the screendepth > 8 - we abandon palette mappings altogether - * because pixel values can be calculated without X server - * assistance. - * - * Windows palette manager is described in the - * http://premium.microsoft.com/msdn/library/techart/f30/f34/f40/d4d/sa942.htm - */ - -typedef struct -{ - Colormap colorMap; - UINT16 size; - UINT16 flags; - INT monoPlane; /* bit plane different for white and black pixels */ - - INT (*mapColor)( DC*, COLORREF ); -} CSPACE; - -static CSPACE cSpace = {0, 0, 0}; +#include "palette.h" +#include "windef.h" -static int COLOR_Redshift = 0; /* to handle abortive COLOR_VIRTUAL visuals */ -static int COLOR_Redmax = 0; -static int COLOR_Greenshift = 0; -static int COLOR_Greenmax = 0; -static int COLOR_Blueshift = 0; -static int COLOR_Bluemax = 0; -static int COLOR_Graymax = 0; -/* System color space. +/*********************************************************************** + * System color space. * * First 10 and last 10 colors in COLOR_sysPalette are * "guarded". RealizePalette changes only the rest of colorcells. For * currently inactive window it changes only DC palette mappings. */ -#define NB_COLORCUBE_START_INDEX 63 - -Visual* visual = NULL; +PALETTEENTRY *COLOR_sysPal = NULL; /* current system palette */ -static PALETTEENTRY* COLOR_sysPal = NULL; /* current system palette */ -static int COLOR_gapStart = 256; -static int COLOR_gapEnd = -1; -static int COLOR_gapFilled = 0; -static int COLOR_max = 256; +int COLOR_gapStart = 256; +int COLOR_gapEnd = -1; +int COLOR_gapFilled = 0; +int COLOR_max = 256; - /* First free dynamic color cell, 0 = full palette, -1 = fixed palette */ -static int COLOR_firstFree = 0; -static unsigned char COLOR_freeList[256]; - - /* Maps entry in the system palette to X pixel value */ -int* COLOR_PaletteToPixel = NULL; - - /* Maps pixel to the entry in the system palette */ -int* COLOR_PixelToPalette = NULL; - -static const PALETTEENTRY __sysPalTemplate[NB_RESERVED_COLORS] = +const PALETTEENTRY COLOR_sysPalTemplate[NB_RESERVED_COLORS] = { /* first 10 entries in the system palette */ /* red green blue flags */ @@ -116,573 +59,21 @@ static const PALETTEENTRY __sysPalTemplate[NB_RESERVED_COLORS] = { 0xff, 0xff, 0xff, PC_SYS_USED } /* last 10 */ }; - /* Map an EGA index (0..15) to a pixel value in the system color space. */ - -int COLOR_mapEGAPixel[16]; - /*********************************************************************** - * Misc auxiliary functions + * COLOR_GetSystemPaletteTemplate */ -Colormap X11DRV_COLOR_GetColormap(void) -{ - return cSpace.colorMap; -} - -BOOL COLOR_GetMonoPlane(INT* plane) -{ - *plane = cSpace.monoPlane; - return (cSpace.flags & COLOR_WHITESET) ? TRUE : FALSE; -} - -UINT16 COLOR_GetSystemPaletteSize(void) -{ - return (cSpace.flags & COLOR_PRIVATE) ? cSpace.size : 256; -} - -UINT16 COLOR_GetSystemPaletteFlags(void) -{ - return cSpace.flags; -} - const PALETTEENTRY* COLOR_GetSystemPaletteTemplate(void) { - return __sysPalTemplate; -} - -COLORREF COLOR_GetSystemPaletteEntry(UINT i) -{ - return *(COLORREF*)(COLOR_sysPal + i) & 0x00ffffff; -} - -void COLOR_FormatSystemPalette(void) -{ - /* Build free list so we'd have an easy way to find - * out if there are any available colorcells. - */ - - int i, j = COLOR_firstFree = NB_RESERVED_COLORS/2; - - COLOR_sysPal[j].peFlags = 0; - for( i = NB_RESERVED_COLORS/2 + 1 ; i < 256 - NB_RESERVED_COLORS/2 ; i++ ) - if( i < COLOR_gapStart || i > COLOR_gapEnd ) - { - COLOR_sysPal[i].peFlags = 0; /* unused tag */ - COLOR_freeList[j] = i; /* next */ - j = i; - } - COLOR_freeList[j] = 0; -} - -BOOL COLOR_CheckSysColor(COLORREF c) -{ - int i; - for( i = 0; i < NB_RESERVED_COLORS; i++ ) - if( c == (*(COLORREF*)(__sysPalTemplate + i) & 0x00ffffff) ) - return 0; - return 1; + return COLOR_sysPalTemplate; } /*********************************************************************** - * Colormap Initialization + * COLOR_GetSystemPaletteEntry */ -static void COLOR_FillDefaultColors(void) -{ - /* initialize unused entries to what Windows uses as a color - * cube - based on Greg Kreider's code. - */ - - int i = 0, idx = 0; - int red, no_r, inc_r; - int green, no_g, inc_g; - int blue, no_b, inc_b; - - if (cSpace.size <= NB_RESERVED_COLORS) - return; - while (i*i*i < (cSpace.size - NB_RESERVED_COLORS)) i++; - no_r = no_g = no_b = --i; - if ((no_r * (no_g+1) * no_b) < (cSpace.size - NB_RESERVED_COLORS)) no_g++; - if ((no_r * no_g * (no_b+1)) < (cSpace.size - NB_RESERVED_COLORS)) no_b++; - inc_r = (255 - NB_COLORCUBE_START_INDEX)/no_r; - inc_g = (255 - NB_COLORCUBE_START_INDEX)/no_g; - inc_b = (255 - NB_COLORCUBE_START_INDEX)/no_b; - - idx = COLOR_firstFree; - - if( idx != -1 ) - for (blue = NB_COLORCUBE_START_INDEX; blue < 256 && idx; blue += inc_b ) - for (green = NB_COLORCUBE_START_INDEX; green < 256 && idx; green += inc_g ) - for (red = NB_COLORCUBE_START_INDEX; red < 256 && idx; red += inc_r ) - { - /* weird but true */ - - if( red == NB_COLORCUBE_START_INDEX && green == red && blue == green ) continue; - - COLOR_sysPal[idx].peRed = red; - COLOR_sysPal[idx].peGreen = green; - COLOR_sysPal[idx].peBlue = blue; - - /* set X color */ - - if( cSpace.flags & COLOR_VIRTUAL ) - { - if (COLOR_Redmax != 255) no_r = (red * COLOR_Redmax) / 255; - if (COLOR_Greenmax != 255) no_g = (green * COLOR_Greenmax) / 255; - if (COLOR_Bluemax != 255) no_b = (blue * COLOR_Bluemax) / 255; - - COLOR_PaletteToPixel[idx] = (no_r << COLOR_Redshift) | (no_g << COLOR_Greenshift) | (no_b << COLOR_Blueshift); - } - else if( !(cSpace.flags & COLOR_FIXED) ) - { - XColor color = { color.pixel = (COLOR_PaletteToPixel)? COLOR_PaletteToPixel[idx] : idx , - COLOR_sysPal[idx].peRed << 8, - COLOR_sysPal[idx].peGreen << 8, - COLOR_sysPal[idx].peGreen << 8, - (DoRed | DoGreen | DoBlue) }; - TSXStoreColor(display, cSpace.colorMap, &color); - } - idx = COLOR_freeList[idx]; - } - - /* try to fill some entries in the "gap" with - * what's already in the colormap - they will be - * mappable to but not changeable. */ - - if( COLOR_gapStart < COLOR_gapEnd && COLOR_PixelToPalette ) - { - XColor xc; - int r, g, b, max; - - max = COLOR_max - (256 - (COLOR_gapEnd - COLOR_gapStart)); - for ( i = 0, idx = COLOR_gapStart; i < 256 && idx <= COLOR_gapEnd; i++ ) - if( COLOR_PixelToPalette[i] == 0 ) - { - xc.pixel = i; - - TSXQueryColor(display, cSpace.colorMap, &xc); - r = xc.red>>8; g = xc.green>>8; b = xc.blue>>8; - - if( xc.pixel < 256 && COLOR_CheckSysColor(RGB(r, g, b)) && - TSXAllocColor(display, cSpace.colorMap, &xc) ) - { - COLOR_PixelToPalette[xc.pixel] = idx; - COLOR_PaletteToPixel[idx] = xc.pixel; - *(COLORREF*)(COLOR_sysPal + idx) = RGB(r, g, b); - COLOR_sysPal[idx++].peFlags |= PC_SYS_USED; - if( --max <= 0 ) break; - } - } - COLOR_gapFilled = idx - COLOR_gapStart; - } -} - -/*********************************************************************** - * COLOR_BuildPrivateMap/COLOR_BuildSharedMap - * - * Allocate colorcells and initialize mapping tables. - */ -static BOOL COLOR_BuildPrivateMap(CSPACE* cs) -{ - /* Private colormap - identity mapping */ - - XColor color; - int i; - - COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*cs->size); - - TRACE(palette,"Building private map - %i palette entries\n", cs->size); - - /* Allocate system palette colors */ - - for( i=0; i < cs->size; i++ ) - { - if( i < NB_RESERVED_COLORS/2 ) - { - color.red = __sysPalTemplate[i].peRed * 65535 / 255; - color.green = __sysPalTemplate[i].peGreen * 65535 / 255; - color.blue = __sysPalTemplate[i].peBlue * 65535 / 255; - COLOR_sysPal[i] = __sysPalTemplate[i]; - } - else if( i >= cs->size - NB_RESERVED_COLORS/2 ) - { - int j = NB_RESERVED_COLORS + i - cs->size; - color.red = __sysPalTemplate[j].peRed * 65535 / 255; - color.green = __sysPalTemplate[j].peGreen * 65535 / 255; - color.blue = __sysPalTemplate[j].peBlue * 65535 / 255; - COLOR_sysPal[i] = __sysPalTemplate[j]; - } - - color.flags = DoRed | DoGreen | DoBlue; - color.pixel = i; - TSXStoreColor(display, cs->colorMap, &color); - - /* Set EGA mapping if color is from the first or last eight */ - - if (i < 8) - COLOR_mapEGAPixel[i] = color.pixel; - else if (i >= cs->size - 8 ) - COLOR_mapEGAPixel[i - (cs->size - 16)] = color.pixel; - } - - COLOR_PixelToPalette = COLOR_PaletteToPixel = NULL; - - COLOR_gapStart = 256; COLOR_gapEnd = -1; - - COLOR_firstFree = (cs->size > NB_RESERVED_COLORS)?NB_RESERVED_COLORS/2 : -1; - - return FALSE; -} - -static BOOL COLOR_BuildSharedMap(CSPACE* cs) -{ - XColor color; - unsigned long sysPixel[NB_RESERVED_COLORS]; - unsigned long* pixDynMapping = NULL; - unsigned long plane_masks[1]; - int i, j, warn = 0; - int diff, r, g, b, max = 256, bp = 0, wp = 1; - int step = 1; - - /* read "AllocSystemColors" from wine.conf */ - - COLOR_max = PROFILE_GetWineIniInt( "options", "AllocSystemColors", 256); - if (COLOR_max > 256) COLOR_max = 256; - else if (COLOR_max < 20) COLOR_max = 20; - TRACE(palette,"%d colors configured.\n", COLOR_max); - - TRACE(palette,"Building shared map - %i palette entries\n", cs->size); - - /* Be nice and allocate system colors as read-only */ - - for( i = 0; i < NB_RESERVED_COLORS; i++ ) - { - color.red = __sysPalTemplate[i].peRed * 65535 / 255; - color.green = __sysPalTemplate[i].peGreen * 65535 / 255; - color.blue = __sysPalTemplate[i].peBlue * 65535 / 255; - color.flags = DoRed | DoGreen | DoBlue; - - if (!TSXAllocColor( display, cSpace.colorMap, &color )) - { - XColor best, c; - - if( !warn++ ) - { - WARN(palette, "Not enough colors for the full system palette.\n"); - - bp = BlackPixel(display, DefaultScreen(display)); - wp = WhitePixel(display, DefaultScreen(display)); - - max = (0xffffffff)>>(32 - MONITOR_GetDepth(&MONITOR_PrimaryMonitor)); - if( max > 256 ) - { - step = max/256; - max = 256; - } - } - - /* reinit color (XAllocColor() may change it) - * and map to the best shared colorcell */ - - color.red = __sysPalTemplate[i].peRed * 65535 / 255; - color.green = __sysPalTemplate[i].peGreen * 65535 / 255; - color.blue = __sysPalTemplate[i].peBlue * 65535 / 255; - - best.pixel = best.red = best.green = best.blue = 0; - for( c.pixel = 0, diff = 0x7fffffff; c.pixel < max; c.pixel += step ) - { - TSXQueryColor(display, cSpace.colorMap, &c); - r = (c.red - color.red)>>8; - g = (c.green - color.green)>>8; - b = (c.blue - color.blue)>>8; - r = r*r + g*g + b*b; - if( r < diff ) { best = c; diff = r; } - } - - if( TSXAllocColor(display, cSpace.colorMap, &best) ) - color.pixel = best.pixel; - else color.pixel = (i < NB_RESERVED_COLORS/2)? bp : wp; - } - - sysPixel[i] = color.pixel; - - TRACE(palette,"syscolor(%lx) -> pixel %i\n", - *(COLORREF*)(__sysPalTemplate+i), (int)color.pixel); - - /* Set EGA mapping if color in the first or last eight */ - - if (i < 8) - COLOR_mapEGAPixel[i] = color.pixel; - else if (i >= NB_RESERVED_COLORS - 8 ) - COLOR_mapEGAPixel[i - (NB_RESERVED_COLORS-16)] = color.pixel; - } - - /* now allocate changeable set */ - - if( !(cSpace.flags & COLOR_FIXED) ) - { - int c_min = 0, c_max = cs->size, c_val; - - TRACE(palette,"Dynamic colormap... \n"); - - /* comment this out if you want to debug palette init */ - - TSXGrabServer(display); - - /* let's become the first client that actually follows - * X guidelines and does binary search... - */ - - pixDynMapping = (unsigned long*)xmalloc(sizeof(long)*cs->size); - while( c_max - c_min > 0 ) - { - c_val = (c_max + c_min)/2 + (c_max + c_min)%2; - - if( !TSXAllocColorCells(display, cs->colorMap, False, - plane_masks, 0, pixDynMapping, c_val) ) - c_max = c_val - 1; - else - { - TSXFreeColors(display, cs->colorMap, pixDynMapping, c_val, 0); - c_min = c_val; - } - } - - if( c_min > COLOR_max - NB_RESERVED_COLORS) - c_min = COLOR_max - NB_RESERVED_COLORS; - - c_min = (c_min/2) + (c_min/2); /* need even set for split palette */ - - if( c_min > 0 ) - if( !TSXAllocColorCells(display, cs->colorMap, False, - plane_masks, 0, pixDynMapping, c_min) ) - { - WARN(palette,"Inexplicable failure during colorcell allocation.\n"); - c_min = 0; - } - - cs->size = c_min + NB_RESERVED_COLORS; - - TSXUngrabServer(display); - - TRACE(palette,"adjusted size %i colorcells\n", cs->size); - } - else if( cSpace.flags & COLOR_VIRTUAL ) - { - /* virtual colorspace - ToPhysical takes care of - * color translations but we have to allocate full palette - * to maintain compatibility - */ - cs->size = 256; - TRACE(palette,"Virtual colorspace - screendepth %i\n", MONITOR_GetDepth(&MONITOR_PrimaryMonitor)); - } - else cs->size = NB_RESERVED_COLORS; /* system palette only - however we can alloc a bunch - * of colors and map to them */ - - TRACE(palette,"Shared system palette uses %i colors.\n", cs->size); - - /* set gap to account for pixel shortage. It has to be right in the center - * of the system palette because otherwise raster ops get screwed. */ - - if( cs->size >= 256 ) - { COLOR_gapStart = 256; COLOR_gapEnd = -1; } - else - { COLOR_gapStart = cs->size/2; COLOR_gapEnd = 255 - cs->size/2; } - - COLOR_firstFree = ( cs->size > NB_RESERVED_COLORS && - (cs->flags & COLOR_VIRTUAL || !(cs->flags & COLOR_FIXED)) ) - ? NB_RESERVED_COLORS/2 : -1; - - COLOR_sysPal = (PALETTEENTRY*)xmalloc(sizeof(PALETTEENTRY)*256); - - /* setup system palette entry <-> pixel mappings and fill in 20 fixed entries */ - - if( MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8 ) - { - COLOR_PixelToPalette = (int*)xmalloc(sizeof(int)*256); - memset( COLOR_PixelToPalette, 0, 256*sizeof(int) ); - } - - /* for hicolor visuals PaletteToPixel mapping is used to skip - * RGB->pixel calculation in COLOR_ToPhysical(). - */ - - COLOR_PaletteToPixel = (int*)xmalloc(sizeof(int)*256); - - for( i = j = 0; i < 256; i++ ) - { - if( i >= COLOR_gapStart && i <= COLOR_gapEnd ) - { - COLOR_PaletteToPixel[i] = 0; - COLOR_sysPal[i].peFlags = 0; /* mark as unused */ - continue; - } - - if( i < NB_RESERVED_COLORS/2 ) - { - COLOR_PaletteToPixel[i] = sysPixel[i]; - COLOR_sysPal[i] = __sysPalTemplate[i]; - } - else if( i >= 256 - NB_RESERVED_COLORS/2 ) - { - COLOR_PaletteToPixel[i] = sysPixel[(i + NB_RESERVED_COLORS) - 256]; - COLOR_sysPal[i] = __sysPalTemplate[(i + NB_RESERVED_COLORS) - 256]; - } - else if( pixDynMapping ) - COLOR_PaletteToPixel[i] = pixDynMapping[j++]; - else - COLOR_PaletteToPixel[i] = i; - - TRACE(palette,"index %i -> pixel %i\n", i, COLOR_PaletteToPixel[i]); - - if( COLOR_PixelToPalette ) - COLOR_PixelToPalette[COLOR_PaletteToPixel[i]] = i; - } - if( pixDynMapping ) free(pixDynMapping); - - return TRUE; -} - -/*********************************************************************** - * COLOR_Computeshifts - * - * Calculate conversion parameters for direct mapped visuals - */ -static void COLOR_Computeshifts(unsigned long maskbits, int *shift, int *max) -{ - int i; - - if (maskbits==0) - { - *shift=0; - *max=0; - return; - } - - for(i=0;!(maskbits&1);i++) - maskbits >>= 1; - - *shift = i; - *max = maskbits; -} - - -/*********************************************************************** - * COLOR_Init - * - * Initialize color management. - */ -BOOL COLOR_Init(void) -{ - int mask, white, black; - - visual = DefaultVisual( display, DefaultScreen(display) ); - - TRACE(palette,"initializing palette manager...\n"); - - white = WhitePixelOfScreen( X11DRV_GetXScreen() ); - black = BlackPixelOfScreen( X11DRV_GetXScreen() ); - cSpace.monoPlane = 1; - for( mask = 1; !((white & mask)^(black & mask)); mask <<= 1 ) - cSpace.monoPlane++; - cSpace.flags = (white & mask) ? COLOR_WHITESET : 0; - cSpace.size = visual->map_entries; - - switch(visual->class) - { - case DirectColor: - cSpace.flags |= COLOR_VIRTUAL; - case GrayScale: - case PseudoColor: - if (Options.usePrivateMap) - { - XSetWindowAttributes win_attr; - - cSpace.colorMap = TSXCreateColormap( display, X11DRV_GetXRootWindow(), - visual, AllocAll ); - if (cSpace.colorMap) - { - cSpace.flags |= (COLOR_PRIVATE | COLOR_WHITESET); - - cSpace.monoPlane = 1; - for( white = cSpace.size - 1; !(white & 1); white >>= 1 ) - cSpace.monoPlane++; - - if( X11DRV_GetXRootWindow() != DefaultRootWindow(display) ) - { - win_attr.colormap = cSpace.colorMap; - TSXChangeWindowAttributes( display, X11DRV_GetXRootWindow(), - CWColormap, &win_attr ); - } - break; - } - } - cSpace.colorMap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); - break; - - case StaticGray: - cSpace.colorMap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); - cSpace.flags |= COLOR_FIXED; - COLOR_Graymax = (1<<MONITOR_GetDepth(&MONITOR_PrimaryMonitor))-1; - break; - - case TrueColor: - cSpace.flags |= COLOR_VIRTUAL; - case StaticColor: { - int *depths,nrofdepths; - /* FIXME: hack to detect XFree32 XF_VGA16 ... We just have - * depths 1 and 4 - */ - depths=TSXListDepths(display,DefaultScreen(display),&nrofdepths); - if ((nrofdepths==2) && ((depths[0]==4) || depths[1]==4)) { - cSpace.monoPlane = 1; - for( white = cSpace.size - 1; !(white & 1); white >>= 1 ) - cSpace.monoPlane++; - cSpace.flags = (white & mask) ? COLOR_WHITESET : 0; - cSpace.colorMap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); - TSXFree(depths); - break; - } - TSXFree(depths); - cSpace.colorMap = DefaultColormapOfScreen( X11DRV_GetXScreen() ); - cSpace.flags |= COLOR_FIXED; - COLOR_Computeshifts(visual->red_mask, &COLOR_Redshift, &COLOR_Redmax); - COLOR_Computeshifts(visual->green_mask, &COLOR_Greenshift, &COLOR_Greenmax); - COLOR_Computeshifts(visual->blue_mask, &COLOR_Blueshift, &COLOR_Bluemax); - break; - } - } - - TRACE(palette," visual class %i (%i)\n", - visual->class, cSpace.monoPlane); - - memset(COLOR_freeList, 0, 256*sizeof(unsigned char)); - - if (cSpace.flags & COLOR_PRIVATE) - COLOR_BuildPrivateMap( &cSpace ); - else - COLOR_BuildSharedMap( &cSpace ); - - /* Build free list */ - - if( COLOR_firstFree != -1 ) - COLOR_FormatSystemPalette(); - - COLOR_FillDefaultColors(); - - return TRUE; -} - -/*********************************************************************** - * COLOR_Cleanup - * - * Free external colors we grabbed in the FillDefaultPalette() - */ -void COLOR_Cleanup(void) +COLORREF COLOR_GetSystemPaletteEntry(UINT i) { - if( COLOR_gapFilled ) - TSXFreeColors(display, cSpace.colorMap, - (unsigned long*)(COLOR_PaletteToPixel + COLOR_gapStart), - COLOR_gapFilled, 0); + return *(COLORREF*)(COLOR_sysPal + i) & 0x00ffffff; } /*********************************************************************** @@ -709,7 +100,6 @@ BOOL COLOR_IsSolid( COLORREF color ) return FALSE; } - /*********************************************************************** * COLOR_PaletteLookupPixel */ @@ -736,35 +126,6 @@ int COLOR_PaletteLookupPixel( PALETTEENTRY* palPalEntry, int size, return (mapping) ? mapping[best] : best; } -/*********************************************************************** - * COLOR_LookupSystemPixel - */ -int COLOR_LookupSystemPixel(COLORREF col) -{ - int i, best = 0, diff = 0x7fffffff; - int size = COLOR_GetSystemPaletteSize(); - int r,g,b; - - for( i = 0; i < size && diff ; i++ ) - { - if( i == NB_RESERVED_COLORS/2 ) - { - int newi = size - NB_RESERVED_COLORS/2; - if (newi>i) i=newi; - } - - r = COLOR_sysPal[i].peRed - GetRValue(col); - g = COLOR_sysPal[i].peGreen - GetGValue(col); - b = COLOR_sysPal[i].peBlue - GetBValue(col); - - r = r*r + g*g + b*b; - - if( r < diff ) { best = i; diff = r; } - } - - return (COLOR_PaletteToPixel)? COLOR_PaletteToPixel[best] : best; -} - /*********************************************************************** * COLOR_PaletteLookupExactIndex */ @@ -812,282 +173,3 @@ COLORREF COLOR_LookupNearestColor( PALETTEENTRY* palPalEntry, int size, COLORREF return (0x00ffffff & *(COLORREF*) (COLOR_sysPal + COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL, color, FALSE))); } - -/*********************************************************************** - * COLOR_ToLogical - * - * Return RGB color for given X pixel. - */ -COLORREF COLOR_ToLogical(int pixel) -{ - XColor color; - -#if 0 - /* truecolor visual */ - - if (MONITOR_GetDepth(&MONITOR_PrimaryMonitor) >= 24) return pixel; -#endif - - /* check for hicolor visuals first */ - - if ( cSpace.flags & COLOR_FIXED && !COLOR_Graymax ) - { - color.red = (pixel >> COLOR_Redshift) & COLOR_Redmax; - color.green = (pixel >> COLOR_Greenshift) & COLOR_Greenmax; - color.blue = (pixel >> COLOR_Blueshift) & COLOR_Bluemax; - return RGB((color.red * 255)/COLOR_Redmax, - (color.green * 255)/COLOR_Greenmax, - (color.blue * 255)/COLOR_Bluemax); - } - - /* check if we can bypass X */ - - if ((MONITOR_GetDepth(&MONITOR_PrimaryMonitor) <= 8) && (pixel < 256) && - !(cSpace.flags & (COLOR_VIRTUAL | COLOR_FIXED)) ) - return ( *(COLORREF*)(COLOR_sysPal + - ((COLOR_PixelToPalette)?COLOR_PixelToPalette[pixel]:pixel)) ) & 0x00ffffff; - - color.pixel = pixel; - TSXQueryColor(display, cSpace.colorMap, &color); - return RGB(color.red >> 8, color.green >> 8, color.blue >> 8); -} - - -/*********************************************************************** - * COLOR_ToPhysical - * - * Return the physical color closest to 'color'. - */ -int COLOR_ToPhysical( DC *dc, COLORREF color ) -{ - WORD index = 0; - HPALETTE16 hPal = (dc)? dc->w.hPalette: STOCK_DEFAULT_PALETTE; - unsigned char spec_type = color >> 24; - PALETTEOBJ* palPtr = (PALETTEOBJ *) GDI_GetObjPtr( hPal, PALETTE_MAGIC ); - - if ( cSpace.flags & COLOR_FIXED ) - { - /* there is no colormap limitation; we are going to have to compute - * the pixel value from the visual information stored earlier - */ - - unsigned long red, green, blue; - unsigned idx = 0; - - switch(spec_type) - { - case 2: /* PALETTERGB - not sure if we really need to search palette */ - - idx = COLOR_PaletteLookupPixel( palPtr->logpalette.palPalEntry, - palPtr->logpalette.palNumEntries, - NULL, color, FALSE); - - if( palPtr->mapping ) - { - GDI_HEAP_UNLOCK( hPal ); - return palPtr->mapping[idx]; - } - - color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx); - break; - - case 1: /* PALETTEINDEX */ - - if( (idx = color & 0xffff) >= palPtr->logpalette.palNumEntries) - { - WARN(palette, "RGB(%lx) : idx %d is out of bounds, assuming black\n", color, idx); - GDI_HEAP_UNLOCK( hPal ); - return 0; - } - - if( palPtr->mapping ) - { - GDI_HEAP_UNLOCK( hPal ); - return palPtr->mapping[idx]; - } - color = *(COLORREF*)(palPtr->logpalette.palPalEntry + idx); - break; - - default: - color &= 0xffffff; - /* fall through to RGB */ - - case 0: /* RGB */ - if( dc && (dc->w.bitsPerPixel == 1) ) - { - GDI_HEAP_UNLOCK( hPal ); - return (((color >> 16) & 0xff) + - ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0; - } - - } - - red = GetRValue(color); green = GetGValue(color); blue = GetBValue(color); - - if (COLOR_Graymax) - { - /* grayscale only; return scaled value */ - GDI_HEAP_UNLOCK( hPal ); - return ( (red * 30 + green * 69 + blue * 11) * COLOR_Graymax) / 25500; - } - else - { - /* scale each individually and construct the TrueColor pixel value */ - if (COLOR_Redmax != 255) red = (red * COLOR_Redmax) / 255; - if (COLOR_Greenmax != 255) green = (green * COLOR_Greenmax) / 255; - if (COLOR_Bluemax != 255) blue = (blue * COLOR_Bluemax) / 255; - - GDI_HEAP_UNLOCK( hPal ); - return (red << COLOR_Redshift) | (green << COLOR_Greenshift) | (blue << COLOR_Blueshift); - } - } - else - { - - /* palPtr can be NULL when DC is being destroyed */ - - if( !palPtr ) return 0; - else if( !palPtr->mapping ) - WARN(palette, "Palette %04x is not realized\n", dc->w.hPalette); - - switch(spec_type) /* we have to peruse DC and system palette */ - { - default: - color &= 0xffffff; - /* fall through to RGB */ - - case 0: /* RGB */ - if( dc && (dc->w.bitsPerPixel == 1) ) - { - GDI_HEAP_UNLOCK( hPal ); - return (((color >> 16) & 0xff) + - ((color >> 8) & 0xff) + (color & 0xff) > 255*3/2) ? 1 : 0; - } - - index = COLOR_PaletteLookupPixel( COLOR_sysPal, 256, - COLOR_PaletteToPixel, color, FALSE); - - /* TRACE(palette,"RGB(%lx) -> pixel %i\n", color, index); - */ - break; - case 1: /* PALETTEINDEX */ - index = color & 0xffff; - - if( index >= palPtr->logpalette.palNumEntries ) - WARN(palette, "RGB(%lx) : index %i is out of bounds\n", color, index); - else if( palPtr->mapping ) index = palPtr->mapping[index]; - - /* TRACE(palette,"PALETTEINDEX(%04x) -> pixel %i\n", (WORD)color, index); - */ - break; - case 2: /* PALETTERGB */ - index = COLOR_PaletteLookupPixel( palPtr->logpalette.palPalEntry, - palPtr->logpalette.palNumEntries, - palPtr->mapping, color, FALSE); - /* TRACE(palette,"PALETTERGB(%lx) -> pixel %i\n", color, index); - */ - break; - } - } - - GDI_HEAP_UNLOCK( hPal ); - return index; -} - -/*********************************************************************** - * COLOR_SetMapping - * - * Set the color-mapping table for selected palette. - * Return number of entries which mapping has changed. - */ -int COLOR_SetMapping( PALETTEOBJ* palPtr, UINT uStart, UINT uNum, BOOL mapOnly ) -{ - char flag; - int prevMapping = (palPtr->mapping) ? 1 : 0; - int index, iRemapped = 0; - - /* reset dynamic system palette entries */ - - if( !mapOnly && COLOR_firstFree != -1) - COLOR_FormatSystemPalette(); - - /* initialize palette mapping table */ - - palPtr->mapping = (int*)xrealloc(palPtr->mapping, sizeof(int)* - palPtr->logpalette.palNumEntries); - - for( uNum += uStart; uStart < uNum; uStart++ ) - { - index = -1; - flag = PC_SYS_USED; - - switch( palPtr->logpalette.palPalEntry[uStart].peFlags & 0x07 ) - { - case PC_EXPLICIT: /* palette entries are indices into system palette */ - index = *(WORD*)(palPtr->logpalette.palPalEntry + uStart); - if( index > 255 || (index >= COLOR_gapStart && index <= COLOR_gapEnd) ) - { - WARN(palette,"PC_EXPLICIT: idx %d out of system palette, assuming black.\n", index); - index = 0; - } - break; - - case PC_RESERVED: /* forbid future mappings to this entry */ - flag |= PC_SYS_RESERVED; - - /* fall through */ - default: /* try to collapse identical colors */ - index = COLOR_PaletteLookupExactIndex(COLOR_sysPal, 256, - *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart)); - /* fall through */ - case PC_NOCOLLAPSE: - if( index < 0 ) - { - if( COLOR_firstFree > 0 && !(cSpace.flags & COLOR_FIXED) ) - { - XColor color; - index = COLOR_firstFree; /* ought to be available */ - COLOR_firstFree = COLOR_freeList[index]; - - color.pixel = (COLOR_PaletteToPixel) ? COLOR_PaletteToPixel[index] : index; - color.red = palPtr->logpalette.palPalEntry[uStart].peRed << 8; - color.green = palPtr->logpalette.palPalEntry[uStart].peGreen << 8; - color.blue = palPtr->logpalette.palPalEntry[uStart].peBlue << 8; - color.flags = DoRed | DoGreen | DoBlue; - TSXStoreColor(display, cSpace.colorMap, &color); - - COLOR_sysPal[index] = palPtr->logpalette.palPalEntry[uStart]; - COLOR_sysPal[index].peFlags = flag; - COLOR_freeList[index] = 0; - - if( COLOR_PaletteToPixel ) index = COLOR_PaletteToPixel[index]; - break; - } - else if ( cSpace.flags & COLOR_VIRTUAL ) - { - index = COLOR_ToPhysical( NULL, 0x00ffffff & - *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart)); - break; - } - - /* we have to map to existing entry in the system palette */ - - index = COLOR_PaletteLookupPixel(COLOR_sysPal, 256, NULL, - *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart), TRUE); - } - palPtr->logpalette.palPalEntry[uStart].peFlags |= PC_SYS_USED; - - if( COLOR_PaletteToPixel ) index = COLOR_PaletteToPixel[index]; - break; - } - - if( !prevMapping || palPtr->mapping[uStart] != index ) iRemapped++; - palPtr->mapping[uStart] = index; - - TRACE(palette,"entry %i (%lx) -> pixel %i\n", uStart, - *(COLORREF*)(palPtr->logpalette.palPalEntry + uStart), index); - - } - return iRemapped; -} - diff --git a/objects/cursoricon.c b/objects/cursoricon.c index a9d21d66a8d21bc3fe14086e03d4ecd8f8ba66d7..c1b70afda792d159d1c063c675dfc2035d7913d2 100644 --- a/objects/cursoricon.c +++ b/objects/cursoricon.c @@ -31,7 +31,9 @@ #include <string.h> #include <stdlib.h> + #include "wine/winbase16.h" +#include "wine/winuser16.h" #include "heap.h" #include "color.h" #include "bitmap.h" @@ -827,7 +829,6 @@ HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon, BOOL bSemiTransparent) unsigned xor_width, and_width, val_base = 0xffffffff >> (32 - bpp); BYTE* pbc = NULL; - COLORREF col; CURSORICONINFO cI; TRACE(icon, "[%04x] %ix%i %ibpp (bogus %ibps)\n", @@ -867,8 +868,7 @@ HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon, BOOL bSemiTransparent) unsigned *psc = (unsigned*)(psPtr + (ix * bpp)/8); unsigned val = ((*psc) >> (ix * bpp)%8) & val_base; - col = COLOR_ToLogical(val); - if( (GetRValue(col) + GetGValue(col) + GetBValue(col)) > 0x180 ) + if(!PALETTE_Driver->pIsDark(val)) { pbc = pxbPtr + ix/8; *pbc |= 0x80 >> (ix%8); diff --git a/objects/dc.c b/objects/dc.c index 32984b03ca1ca762533ffd3d34783e4524b09559..fc10681aaf5e5af2a30822a862d5752328d4af5a 100644 --- a/objects/dc.c +++ b/objects/dc.c @@ -5,8 +5,10 @@ * */ +#ifndef X_DISPLAY_MISSING #include "ts_xlib.h" #include "x11drv.h" +#endif /* !defined(X_DISPLAY_MISSING) */ #include <stdlib.h> #include <string.h> @@ -856,21 +858,27 @@ UINT WINAPI SetTextAlign( HDC hdc, UINT textAlign ) BOOL WINAPI GetDCOrgEx( HDC hDC, LPPOINT lpp ) { DC * dc; - X11DRV_PDEVICE *physDev; if (!lpp) return FALSE; if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return FALSE; - physDev = (X11DRV_PDEVICE *)dc->physDev; +#ifndef X_DISPLAY_MISSING if (!(dc->w.flags & DC_MEMORY)) { + X11DRV_PDEVICE *physDev; Window root; int w, h, border, depth; + + physDev = (X11DRV_PDEVICE *) dc->physDev; + /* FIXME: this is not correct for managed windows */ TSXGetGeometry( display, physDev->drawable, &root, (int*)&lpp->x, (int*)&lpp->y, &w, &h, &border, &depth ); } - else lpp->x = lpp->y = 0; + else +#endif /* !defined(X_DISPLAY_MISSING) */ + lpp->x = lpp->y = 0; + lpp->x += dc->w.DCOrgX; lpp->y += dc->w.DCOrgY; GDI_HEAP_UNLOCK( hDC ); return TRUE; diff --git a/objects/dib.c b/objects/dib.c index 14eea812a9c7e5b6d6a41c98ff1171f0260b95b4..917b8499f1e5a9b139be73472a9c2599480c96e2 100644 --- a/objects/dib.c +++ b/objects/dib.c @@ -3,24 +3,14 @@ * * Copyright 1993,1994 Alexandre Julliard * - * TODO: Still contains some references to X11DRV. */ -#include "ts_xlib.h" -#include "x11drv.h" - -#include <stdlib.h> -#include "dc.h" #include "bitmap.h" #include "callback.h" -#include "palette.h" -#include "global.h" -#include "selectors.h" +#include "dc.h" #include "debug.h" -#include "local.h" -#include "xmalloc.h" /* for XCREATEIMAGE macro */ #include "monitor.h" - +#include "palette.h" /*********************************************************************** * DIB_GetDIBWidthBytes @@ -187,86 +177,34 @@ INT16 WINAPI SetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan, * Failure: 0 */ INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan, - UINT lines, LPCVOID bits, const BITMAPINFO *info, - UINT coloruse ) + UINT lines, LPCVOID bits, const BITMAPINFO *info, + UINT coloruse ) { - DIB_SETIMAGEBITS_DESCR descr; - BITMAPOBJ * bmp; - int height, tmpheight; + DC *dc; + BITMAPOBJ *bitmap; INT result; - /* Check parameters */ - - descr.dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); - if (!descr.dc) - { - descr.dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC); - if (!descr.dc) return 0; - } - if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC ))) - { - GDI_HEAP_UNLOCK( hdc ); - return 0; - } - if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &height, - &descr.infoBpp, &descr.compression ) == -1) + /* Check parameters */ + dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ); + if (!dc) { - GDI_HEAP_UNLOCK( hbitmap ); - GDI_HEAP_UNLOCK( hdc ); - return 0; + dc = (DC *) GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC); + if (!dc) return 0; } - tmpheight = height; - if (height < 0) height = -height; - if (!lines || (startscan >= height)) + + if (!(bitmap = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC ))) { - GDI_HEAP_UNLOCK( hbitmap ); GDI_HEAP_UNLOCK( hdc ); return 0; } - if (startscan + lines > height) lines = height - startscan; - if (descr.infoBpp <= 8) - { - descr.colorMap = X11DRV_DIB_BuildColorMap( descr.dc, coloruse, - bmp->bitmap.bmBitsPixel, - info, &descr.nColorMap ); - if (!descr.colorMap) - { - GDI_HEAP_UNLOCK( hbitmap ); - GDI_HEAP_UNLOCK( hdc ); - return 0; - } - } else - descr.colorMap = 0; - - /* HACK for now */ - if(!bmp->DDBitmap) - X11DRV_CreateBitmap(hbitmap); -{ - X11DRV_PHYSBITMAP *pbitmap = bmp->DDBitmap->physBitmap; - - - descr.bits = bits; - descr.image = NULL; - descr.lines = tmpheight >= 0 ? lines : -lines; - descr.depth = bmp->bitmap.bmBitsPixel; - descr.drawable = pbitmap->pixmap; - descr.gc = BITMAP_GC(bmp); - descr.xSrc = 0; - descr.ySrc = 0; - descr.xDest = 0; - descr.yDest = height - startscan - lines; - descr.width = bmp->bitmap.bmWidth; - descr.height = lines; -} - EnterCriticalSection( &X11DRV_CritSection ); - result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr ); - LeaveCriticalSection( &X11DRV_CritSection ); - - if (descr.colorMap) HeapFree(GetProcessHeap(), 0, descr.colorMap); + result = BITMAP_Driver->pSetDIBits(bitmap, dc, startscan, + lines, bits, info, + coloruse, hbitmap); GDI_HEAP_UNLOCK( hdc ); GDI_HEAP_UNLOCK( hbitmap ); + return result; } @@ -466,34 +404,6 @@ static RGBQUAD DefLogPalette[20] = { /* Copy of Default Logical Palette */ { 0xff, 0xff, 0xff, 0x00 } }; -/********************************************************************* - * DIB_GetNearestIndex - * - * Helper for GetDIBits. - * Returns the nearest colour table index for a given RGB. - * Nearest is defined by minimizing the sum of the squares. - */ -static INT DIB_GetNearestIndex(BITMAPINFO *info, BYTE r, BYTE g, BYTE b) -{ - INT i, best = -1, diff, bestdiff = -1; - RGBQUAD *color; - - for(color = info->bmiColors, i = 0; i < (1 << info->bmiHeader.biBitCount); - color++, i++) { - diff = (r - color->rgbRed) * (r - color->rgbRed) + - (g - color->rgbGreen) * (g - color->rgbGreen) + - (b - color->rgbBlue) * (b - color->rgbBlue); - if(diff == 0) - return i; - if(best == -1 || diff < bestdiff) { - best = i; - bestdiff = diff; - } - } - return best; -} - - /*********************************************************************** * GetDIBits16 (GDI.441) */ @@ -527,8 +437,7 @@ INT WINAPI GetDIBits( BITMAPOBJ * bmp; PALETTEENTRY * palEntry; PALETTEOBJ * palette; - XImage * bmpImage; - int i, x, y; + int i; if (!lines) return 0; if (!info) return 0; @@ -539,9 +448,13 @@ INT WINAPI GetDIBits( if (!dc) return 0; } if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC ))) + { + GDI_HEAP_UNLOCK( hdc ); return 0; + } if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC ))) { + GDI_HEAP_UNLOCK( hdc ); GDI_HEAP_UNLOCK( hbitmap ); return 0; } @@ -602,379 +515,17 @@ INT WINAPI GetDIBits( } } - if (bits) - { - BYTE *bbits = (BYTE*)bits, *linestart; - int dstwidth, yend, xend = bmp->bitmap.bmWidth; - - TRACE(bitmap, "%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n", - lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight, - (int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight, - startscan ); - - /* adjust number of scanlines to copy */ - - if( lines > info->bmiHeader.biHeight ) - lines = info->bmiHeader.biHeight; + GDI_HEAP_UNLOCK( dc->w.hPalette ); - yend = startscan + lines; - if( startscan >= bmp->bitmap.bmHeight ) + if (bits) + { + if(!BITMAP_Driver->pGetDIBits(bmp, dc, startscan, lines, bits, info, coloruse, hbitmap)) { - GDI_HEAP_UNLOCK( hbitmap ); - GDI_HEAP_UNLOCK( dc->w.hPalette ); - return FALSE; - } - if( yend > bmp->bitmap.bmHeight ) yend = bmp->bitmap.bmHeight; - - /* adjust scanline width */ - - if(bmp->bitmap.bmWidth > info->bmiHeader.biWidth) - xend = info->bmiHeader.biWidth; - - /* HACK for now */ - if(!bmp->DDBitmap) - X11DRV_CreateBitmap(hbitmap); - - dstwidth = DIB_GetDIBWidthBytes( info->bmiHeader.biWidth, - info->bmiHeader.biBitCount ); - - EnterCriticalSection( &X11DRV_CritSection ); - bmpImage = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp ); - - linestart = bbits; - switch( info->bmiHeader.biBitCount ) { + GDI_HEAP_UNLOCK( hdc ); + GDI_HEAP_UNLOCK( hbitmap ); - case 1: /* 1 bit DIB */ - { - unsigned long white = (1 << bmp->bitmap.bmBitsPixel) - 1; - - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - if (!(x&7)) *bbits = 0; - *bbits |= (XGetPixel( bmpImage, x, y) >= white) - << (7 - (x&7)); - if ((x&7)==7) bbits++; - } - bbits = (linestart += dstwidth); - } - } - break; - - - case 4: /* 4 bit DIB */ - switch(bmp->bitmap.bmBitsPixel) { - - case 1: /* 1/4 bit bmp -> 4 bit DIB */ - case 4: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - if (!(x&1)) *bbits = 0; - *bbits |= XGetPixel( bmpImage, x, y)<<(4*(1-(x&1))); - if ((x&1)==1) bbits++; - } - bbits = (linestart += dstwidth); - } - break; - - case 8: /* 8 bit bmp -> 4 bit DIB */ - palEntry = palette->logpalette.palPalEntry; - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel = XGetPixel( bmpImage, x, y ); - if (!(x&1)) *bbits = 0; - *bbits |= ( DIB_GetNearestIndex(info, - palEntry[pixel].peRed, - palEntry[pixel].peGreen, - palEntry[pixel].peBlue ) - << (4*(1-(x&1))) ); - if ((x&1)==1) bbits++; - } - bbits = (linestart += dstwidth); - } - break; - - case 15: /* 15/16 bit bmp -> 4 bit DIB */ - case 16: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel = XGetPixel( bmpImage, x, y ); - if (!(x&1)) *bbits = 0; - *bbits |= ( DIB_GetNearestIndex(info, - ((pixel << 3) & 0xf8) | - ((pixel >> 2) & 0x7), - ((pixel >> 2) & 0xf8) | - ((pixel >> 7) & 0x7), - ((pixel >> 7) & 0xf8) | - ((pixel >> 12) & 0x7) ) - << (4*(1-(x&1))) ); - if ((x&1)==1) bbits++; - } - bbits = (linestart += dstwidth); - } - break; - - case 24: /* 24/32 bit bmp -> 4 bit DIB */ - case 32: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel = XGetPixel( bmpImage, x, y ); - if (!(x&1)) *bbits = 0; - *bbits |= ( DIB_GetNearestIndex( info, - (pixel >> 16) & 0xff, - (pixel >> 8) & 0xff, - pixel & 0xff ) - << (4*(1-(x&1))) ); - if ((x&1)==1) bbits++; - } - bbits = (linestart += dstwidth); - } - break; - - default: /* ? bit bmp -> 4 bit DIB */ - FIXME(bitmap, "4 bit DIB %d bit bitmap\n", - bmp->bitmap.bmBitsPixel); - break; - } - break; - - - case 8: /* 8 bit DIB */ - switch(bmp->bitmap.bmBitsPixel) { - - case 1: /* 1/4/8 bit bmp -> 8 bit DIB */ - case 4: - case 8: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) - *bbits++ = XGetPixel( bmpImage, x, y ); - bbits = (linestart += dstwidth); - } - break; - - case 15: /* 15/16 bit bmp -> 8 bit DIB */ - case 16: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel = XGetPixel( bmpImage, x, y ); - *bbits++ = DIB_GetNearestIndex( info, - ((pixel << 3) & 0xf8) | - ((pixel >> 2) & 0x7), - ((pixel >> 2) & 0xf8) | - ((pixel >> 7) & 0x7), - ((pixel >> 7) & 0xf8) | - ((pixel >> 12) & 0x7) ); - } - bbits = (linestart += dstwidth); - } - break; - - case 24: /* 24/32 bit bmp -> 8 bit DIB */ - case 32: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel = XGetPixel( bmpImage, x, y ); - *bbits++ = DIB_GetNearestIndex( info, - (pixel >> 16) & 0xff, - (pixel >> 8) & 0xff, - pixel & 0xff ); - } - bbits = (linestart += dstwidth); - } - break; - - default: /* ? bit bmp -> 8 bit DIB */ - FIXME(bitmap, "8 bit DIB %d bit bitmap\n", - bmp->bitmap.bmBitsPixel); - break; - } - break; - - - case 15: /* 15/16 bit DIB */ - case 16: - switch(bmp->bitmap.bmBitsPixel) { - - case 15: /* 15/16 bit bmp -> 16 bit DIB */ - case 16: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = pixel & 0xff; - *bbits++ = (pixel >> 8) & 0xff; - } - bbits = (linestart += dstwidth); - } - break; - - case 24: /* 24/32 bit bmp -> 16 bit DIB */ - case 32: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = ((pixel >> 6) & 0xe0) | - ((pixel >> 3) & 0x1f); - *bbits++ = ((pixel >> 17) & 0x7c) | - ((pixel >> 14) & 0x3); - } - bbits = (linestart += dstwidth); - } - break; - - case 1: /* 1/4/8 bit bmp -> 16 bit DIB */ - case 4: - case 8: - palEntry = palette->logpalette.palPalEntry; - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = ((palEntry[pixel].peBlue >> 3) & 0x1f) | - ((palEntry[pixel].peGreen << 2) & 0xe0); - *bbits++ = ((palEntry[pixel].peGreen >> 6) & 0x3) | - ((palEntry[pixel].peRed >> 1) & 0x7c); - } - bbits = (linestart += dstwidth); - } - break; - - default: /* ? bit bmp -> 16 bit DIB */ - FIXME(bitmap, "15/16 bit DIB %d bit bitmap\n", - bmp->bitmap.bmBitsPixel); - break; - } - break; - - - case 24: /* 24 bit DIB */ - switch(bmp->bitmap.bmBitsPixel) { - - case 24: /* 24/32 bit bmp -> 24 bit DIB */ - case 32: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = (pixel >>16) & 0xff; - *bbits++ = (pixel >> 8) & 0xff; - *bbits++ = pixel & 0xff; - } - bbits = (linestart += dstwidth); - } - break; - - case 15: /* 15/16 bit bmp -> 24 bit DIB */ - case 16: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = ((pixel >> 7) & 0xf8) | - ((pixel >> 12) & 0x7); - *bbits++ = ((pixel >> 2) & 0xf8) | - ((pixel >> 7) & 0x7); - *bbits++ = ((pixel << 3) & 0xf8) | - ((pixel >> 2) & 0x7); - } - bbits = (linestart += dstwidth); - } - break; - - case 1: /* 1/4/8 bit bmp -> 24 bit DIB */ - case 4: - case 8: - palEntry = palette->logpalette.palPalEntry; - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = palEntry[pixel].peBlue; - *bbits++ = palEntry[pixel].peGreen; - *bbits++ = palEntry[pixel].peRed; - } - bbits = (linestart += dstwidth); - } - break; - - default: /* ? bit bmp -> 24 bit DIB */ - FIXME(bitmap, "24 bit DIB %d bit bitmap\n", - bmp->bitmap.bmBitsPixel); - break; - } - break; - - - case 32: /* 32 bit DIB */ - switch(bmp->bitmap.bmBitsPixel) { - - case 24: /* 24/32 bit bmp -> 32 bit DIB */ - case 32: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = (pixel >>16) & 0xff; - *bbits++ = (pixel >> 8) & 0xff; - *bbits++ = pixel & 0xff; - *bbits++ = 0; - } - bbits = (linestart += dstwidth); - } - break; - - case 15: /* 15/16 bit bmp -> 32 bit DIB */ - case 16: - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = ((pixel >> 7) & 0xf8) | - ((pixel >> 12) & 0x7); - *bbits++ = ((pixel >> 2) & 0xf8) | - ((pixel >> 7) & 0x7); - *bbits++ = ((pixel << 3) & 0xf8) | - ((pixel >> 2) & 0x7); - *bbits++ = 0; - } - bbits = (linestart += dstwidth); - } - break; - - case 1: /* 1/4/8 bit bmp -> 32 bit DIB */ - case 4: - case 8: - palEntry = palette->logpalette.palPalEntry; - for( y = yend - 1; (int)y >= (int)startscan; y-- ) { - for( x = 0; x < xend; x++ ) { - unsigned long pixel=XGetPixel( bmpImage, x, y); - *bbits++ = palEntry[pixel].peBlue; - *bbits++ = palEntry[pixel].peGreen; - *bbits++ = palEntry[pixel].peRed; - *bbits++ = 0; - } - bbits = (linestart += dstwidth); - } - break; - - default: /* ? bit bmp -> 32 bit DIB */ - FIXME(bitmap, "32 bit DIB %d bit bitmap\n", - bmp->bitmap.bmBitsPixel); - break; - } - break; - - - default: /* ? bit DIB */ - FIXME(bitmap,"Unsupported DIB depth %d\n", - info->bmiHeader.biBitCount); - break; + return FALSE; } - - XDestroyImage( bmpImage ); - LeaveCriticalSection( &X11DRV_CritSection ); - - if(info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */ - info->bmiHeader.biSizeImage = info->bmiHeader.biHeight * - DIB_GetDIBWidthBytes( info->bmiHeader.biWidth, - info->bmiHeader.biBitCount ); - - if(bbits - (BYTE *)bits > info->bmiHeader.biSizeImage) - ERR(bitmap, "Buffer overrun. Please investigate.\n"); - - info->bmiHeader.biCompression = 0; } else if( info->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) ) { @@ -1002,8 +553,10 @@ INT WINAPI GetDIBits( TRACE(bitmap, "biSizeImage = %ld, biWidth = %ld, biHeight = %ld\n", info->bmiHeader.biSizeImage, info->bmiHeader.biWidth, info->bmiHeader.biHeight); + + GDI_HEAP_UNLOCK( hdc ); GDI_HEAP_UNLOCK( hbitmap ); - GDI_HEAP_UNLOCK( dc->w.hPalette ); + return lines; } @@ -1089,198 +642,6 @@ HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header, return handle; } - -/*********************************************************************** - * DIB_DoProtectDIBSection - */ -static void DIB_DoProtectDIBSection( BITMAPOBJ *bmp, DWORD new_prot ) -{ - DIBSECTION *dib = &bmp->dib->dibSection; - INT effHeight = dib->dsBm.bmHeight >= 0? dib->dsBm.bmHeight - : -dib->dsBm.bmHeight; - INT totalSize = dib->dsBmih.biSizeImage? dib->dsBmih.biSizeImage - : dib->dsBm.bmWidthBytes * effHeight; - DWORD old_prot; - - VirtualProtect(dib->dsBm.bmBits, totalSize, new_prot, &old_prot); - TRACE(bitmap, "Changed protection from %ld to %ld\n", - old_prot, new_prot); -} - -/*********************************************************************** - * DIB_DoUpdateDIBSection - */ -static void DIB_DoUpdateDIBSection( BITMAPOBJ *bmp, BOOL toDIB ) -{ - DIBSECTIONOBJ *dib = bmp->dib; - DIB_SETIMAGEBITS_DESCR descr; - - if (DIB_GetBitmapInfo( &dib->dibSection.dsBmih, &descr.infoWidth, &descr.lines, - &descr.infoBpp, &descr.compression ) == -1) - return; - - descr.dc = NULL; - descr.image = dib->image; - descr.colorMap = dib->colorMap; - descr.nColorMap = dib->nColorMap; - descr.bits = dib->dibSection.dsBm.bmBits; - descr.depth = bmp->bitmap.bmBitsPixel; - - /* Hack for now */ - descr.drawable = ((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap; - descr.gc = BITMAP_GC(bmp); - descr.xSrc = 0; - descr.ySrc = 0; - descr.xDest = 0; - descr.yDest = 0; - descr.width = bmp->bitmap.bmWidth; - descr.height = bmp->bitmap.bmHeight; - - if (toDIB) - { - TRACE(bitmap, "Copying from Pixmap to DIB bits\n"); - EnterCriticalSection( &X11DRV_CritSection ); - CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr ); - LeaveCriticalSection( &X11DRV_CritSection ); - } - else - { - TRACE(bitmap, "Copying from DIB bits to Pixmap\n"); - EnterCriticalSection( &X11DRV_CritSection ); - CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr ); - LeaveCriticalSection( &X11DRV_CritSection ); - } -} - -/*********************************************************************** - * DIB_FaultHandler - */ -static BOOL DIB_FaultHandler( LPVOID res, LPCVOID addr ) -{ - BOOL handled = FALSE; - BITMAPOBJ *bmp; - - bmp = (BITMAPOBJ *)GDI_GetObjPtr( (HBITMAP)res, BITMAP_MAGIC ); - if (!bmp) return FALSE; - - if (bmp->dib) - switch (bmp->dib->status) - { - case DIB_GdiMod: - TRACE( bitmap, "called in status DIB_GdiMod\n" ); - DIB_DoProtectDIBSection( bmp, PAGE_READWRITE ); - DIB_DoUpdateDIBSection( bmp, TRUE ); - DIB_DoProtectDIBSection( bmp, PAGE_READONLY ); - bmp->dib->status = DIB_InSync; - handled = TRUE; - break; - - case DIB_InSync: - TRACE( bitmap, "called in status DIB_InSync\n" ); - DIB_DoProtectDIBSection( bmp, PAGE_READWRITE ); - bmp->dib->status = DIB_AppMod; - handled = TRUE; - break; - - case DIB_AppMod: - FIXME( bitmap, "called in status DIB_AppMod: " - "this can't happen!\n" ); - break; - - case DIB_NoHandler: - FIXME( bitmap, "called in status DIB_NoHandler: " - "this can't happen!\n" ); - break; - } - - GDI_HEAP_UNLOCK( (HBITMAP)res ); - return handled; -} - -/*********************************************************************** - * DIB_UpdateDIBSection - */ -void DIB_UpdateDIBSection( DC *dc, BOOL toDIB ) -{ - BITMAPOBJ *bmp; - - /* Ensure this is a Compatible DC that has a DIB section selected */ - - if (!dc) return; - if (!(dc->w.flags & DC_MEMORY)) return; - - bmp = (BITMAPOBJ *)GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC ); - if (!bmp) return; - - if (!bmp->dib) - { - GDI_HEAP_UNLOCK(dc->w.hBitmap); - return; - } - - - if (!toDIB) - { - /* Prepare for access to the DIB by GDI functions */ - - switch (bmp->dib->status) - { - default: - case DIB_NoHandler: - DIB_DoUpdateDIBSection( bmp, FALSE ); - break; - - case DIB_GdiMod: - TRACE( bitmap, "fromDIB called in status DIB_GdiMod\n" ); - /* nothing to do */ - break; - - case DIB_InSync: - TRACE( bitmap, "fromDIB called in status DIB_InSync\n" ); - /* nothing to do */ - break; - - case DIB_AppMod: - TRACE( bitmap, "fromDIB called in status DIB_AppMod\n" ); - DIB_DoUpdateDIBSection( bmp, FALSE ); - DIB_DoProtectDIBSection( bmp, PAGE_READONLY ); - bmp->dib->status = DIB_InSync; - break; - } - } - else - { - /* Acknowledge write access to the DIB by GDI functions */ - - switch (bmp->dib->status) - { - default: - case DIB_NoHandler: - DIB_DoUpdateDIBSection( bmp, TRUE ); - break; - - case DIB_GdiMod: - TRACE( bitmap, " toDIB called in status DIB_GdiMod\n" ); - /* nothing to do */ - break; - - case DIB_InSync: - TRACE( bitmap, " toDIB called in status DIB_InSync\n" ); - DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS ); - bmp->dib->status = DIB_GdiMod; - break; - - case DIB_AppMod: - FIXME( bitmap, " toDIB called in status DIB_AppMod: " - "this can't happen!\n" ); - break; - } - } - - - GDI_HEAP_UNLOCK(dc->w.hBitmap); -} - /*********************************************************************** * CreateDIBSection16 (GDI.489) */ @@ -1288,163 +649,35 @@ HBITMAP16 WINAPI CreateDIBSection16 (HDC16 hdc, BITMAPINFO *bmi, UINT16 usage, SEGPTR *bits, HANDLE section, DWORD offset) { - HBITMAP res = CreateDIBSection(hdc, bmi, usage, NULL, section, - offset); + HBITMAP16 hbitmap; + DC *dc = (DC *) GDI_GetObjPtr(hdc, DC_MAGIC); + if(!dc) dc = (DC *) GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC); + if(!dc) return (HBITMAP16) NULL; - if ( res ) - { - BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC); - if ( bmp && bmp->dib ) - { - DIBSECTION *dib = &bmp->dib->dibSection; - INT height = dib->dsBm.bmHeight >= 0 ? - dib->dsBm.bmHeight : -dib->dsBm.bmHeight; - INT size = dib->dsBmih.biSizeImage ? - dib->dsBmih.biSizeImage : dib->dsBm.bmWidthBytes * height; - if ( dib->dsBm.bmBits ) - { - bmp->dib->selector = - SELECTOR_AllocBlock( dib->dsBm.bmBits, size, - SEGMENT_DATA, FALSE, FALSE ); - } - printf("ptr = %p, size =%d, selector = %04x, segptr = %ld\n", - dib->dsBm.bmBits, size, bmp->dib->selector, - PTR_SEG_OFF_TO_SEGPTR(bmp->dib->selector, 0)); -} - GDI_HEAP_UNLOCK( res ); + hbitmap = dc->funcs->pCreateDIBSection16(dc, bmi, usage, bits, section, offset); - if ( bits ) - *bits = PTR_SEG_OFF_TO_SEGPTR( bmp->dib->selector, 0 ); - } + GDI_HEAP_UNLOCK(hdc); - return res; + return hbitmap; } /*********************************************************************** * CreateDIBSection32 (GDI32.36) */ -HBITMAP WINAPI CreateDIBSection (HDC hdc, BITMAPINFO *bmi, UINT usage, - LPVOID *bits,HANDLE section, - DWORD offset) +HBITMAP WINAPI CreateDIBSection(HDC hdc, BITMAPINFO *bmi, UINT usage, + LPVOID *bits, HANDLE section, + DWORD offset) { - HBITMAP res = 0; - BITMAPOBJ *bmp = NULL; - DIBSECTIONOBJ *dib = NULL; - int *colorMap = NULL; - int nColorMap; - - /* Fill BITMAP32 structure with DIB data */ - BITMAPINFOHEADER *bi = &bmi->bmiHeader; - INT effHeight, totalSize; - BITMAP bm; - - TRACE(bitmap, "format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n", - bi->biWidth, bi->biHeight, bi->biPlanes, bi->biBitCount, - bi->biSizeImage, bi->biClrUsed, usage == DIB_PAL_COLORS? "PAL" : "RGB"); - - bm.bmType = 0; - bm.bmWidth = bi->biWidth; - bm.bmHeight = bi->biHeight; - bm.bmWidthBytes = DIB_GetDIBWidthBytes(bm.bmWidth, bi->biBitCount); - bm.bmPlanes = bi->biPlanes; - bm.bmBitsPixel = bi->biBitCount; - bm.bmBits = NULL; - - /* Get storage location for DIB bits */ - effHeight = bm.bmHeight >= 0 ? bm.bmHeight : -bm.bmHeight; - totalSize = bi->biSizeImage? bi->biSizeImage : bm.bmWidthBytes * effHeight; - - if (section) - bm.bmBits = MapViewOfFile(section, FILE_MAP_ALL_ACCESS, - 0L, offset, totalSize); - else - bm.bmBits = VirtualAlloc(NULL, totalSize, - MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE); + HBITMAP hbitmap; + DC *dc = (DC *) GDI_GetObjPtr(hdc, DC_MAGIC); + if(!dc) dc = (DC *) GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC); + if(!dc) return (HBITMAP) NULL; - /* Create Color Map */ - if (bm.bmBits && bm.bmBitsPixel <= 8) - { - DC *dc = hdc? (DC *)GDI_GetObjPtr(hdc, DC_MAGIC) : NULL; - if (hdc && !dc) dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC); + hbitmap = dc->funcs->pCreateDIBSection(dc, bmi, usage, bits, section, offset); - if (!hdc || dc) - colorMap = X11DRV_DIB_BuildColorMap( dc, usage, bm.bmBitsPixel, - bmi, &nColorMap ); - GDI_HEAP_UNLOCK(hdc); - } + GDI_HEAP_UNLOCK(hdc); - /* Allocate Memory for DIB and fill structure */ - if (bm.bmBits) - dib = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DIBSECTIONOBJ)); - if (dib) - { - dib->dibSection.dsBm = bm; - dib->dibSection.dsBmih = *bi; - /* FIXME: dib->dibSection.dsBitfields ??? */ - dib->dibSection.dshSection = section; - dib->dibSection.dsOffset = offset; - - dib->status = DIB_NoHandler; - dib->selector = 0; - - dib->nColorMap = nColorMap; - dib->colorMap = colorMap; - } - - /* Create Device Dependent Bitmap and add DIB pointer */ - if (dib) - { - res = CreateDIBitmap(hdc, bi, 0, NULL, bmi, usage); - if (res) - { - bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC); - if (bmp) - { - bmp->dib = dib; - /* HACK for now */ - if(!bmp->DDBitmap) - X11DRV_CreateBitmap(res); - } - } - } - - /* Create XImage */ - if (dib && bmp) - XCREATEIMAGE( dib->image, bm.bmWidth, effHeight, bmp->bitmap.bmBitsPixel ); - - /* Clean up in case of errors */ - if (!res || !bmp || !dib || !bm.bmBits || (bm.bmBitsPixel <= 8 && !colorMap)) - { - TRACE(bitmap, "got an error res=%08x, bmp=%p, dib=%p, bm.bmBits=%p\n", - res, bmp, dib, bm.bmBits); - if (bm.bmBits) - { - if (section) - UnmapViewOfFile(bm.bmBits), bm.bmBits = NULL; - else - VirtualFree(bm.bmBits, MEM_RELEASE, 0L), bm.bmBits = NULL; - } - - if (dib && dib->image) { XDestroyImage(dib->image); dib->image = NULL; } - if (colorMap) { HeapFree(GetProcessHeap(), 0, colorMap); colorMap = NULL; } - if (dib) { HeapFree(GetProcessHeap(), 0, dib); dib = NULL; } - if (res) { DeleteObject(res); res = 0; } - } - - /* Install fault handler, if possible */ - if (bm.bmBits) - { - if (VIRTUAL_SetFaultHandler(bm.bmBits, DIB_FaultHandler, (LPVOID)res)) - { - DIB_DoProtectDIBSection( bmp, PAGE_READONLY ); - if (dib) dib->status = DIB_InSync; - } - } - - /* Return BITMAP handle and storage location */ - if (res) GDI_HEAP_UNLOCK(res); - if (bm.bmBits && bits) *bits = bm.bmBits; - return res; + return hbitmap; } /*********************************************************************** @@ -1454,27 +687,17 @@ void DIB_DeleteDIBSection( BITMAPOBJ *bmp ) { if (bmp && bmp->dib) { - DIBSECTIONOBJ *dib = bmp->dib; + DIBSECTION *dib = bmp->dib; - if (dib->dibSection.dsBm.bmBits) + if (dib->dsBm.bmBits) { - if (dib->dibSection.dshSection) - UnmapViewOfFile(dib->dibSection.dsBm.bmBits); + if (dib->dshSection) + UnmapViewOfFile(dib->dsBm.bmBits); else - VirtualFree(dib->dibSection.dsBm.bmBits, MEM_RELEASE, 0L); + VirtualFree(dib->dsBm.bmBits, MEM_RELEASE, 0L); } - if (dib->image) - XDestroyImage( dib->image ); - - if (dib->colorMap) - HeapFree(GetProcessHeap(), 0, dib->colorMap); - - if (dib->selector) - { - WORD count = (GET_SEL_LIMIT( dib->selector ) >> 16) + 1; - SELECTOR_FreeBlock( dib->selector, count ); - } + BITMAP_Driver->pDeleteDIBSection(bmp); HeapFree(GetProcessHeap(), 0, dib); bmp->dib = NULL; diff --git a/objects/gdiobj.c b/objects/gdiobj.c index 0996f85b712e42e8088d85b3cdce1aa98bd5b02a..24388bceda0ba82cdf3dbde998a3cb20800d7db5 100644 --- a/objects/gdiobj.c +++ b/objects/gdiobj.c @@ -4,15 +4,14 @@ * Copyright 1993 Alexandre Julliard */ -#include "config.h" - #ifndef X_DISPLAY_MISSING #include "x11drv.h" #else /* !defined(X_DISPLAY_MISSING) */ #include "ttydrv.h" -#endif /* !defined(X_DISPLAY_MISSING) */ +#endif /* !defined(X_DISPLAY_MISSING */ #include <stdlib.h> + #include "bitmap.h" #include "brush.h" #include "dc.h" @@ -25,6 +24,10 @@ #include "debug.h" #include "gdi.h" +/**********************************************************************/ + +GDI_DRIVER *GDI_Driver = NULL; + /*********************************************************************** * GDI stock objects */ @@ -251,16 +254,16 @@ BOOL GDI_Init(void) /* Initialize drivers */ #ifndef X_DISPLAY_MISSING - if( ! X11DRV_Init() ) - return FALSE; + GDI_Driver = &X11DRV_GDI_Driver; #else /* !defined(X_DISPLAY_MISSING) */ - if( ! TTYDRV_GDI_Initialize() ) - return FALSE; -#endif /* !defined(X_DISPLAY_MISSING) */ + GDI_Driver = &TTYDRV_GDI_Driver; +#endif /* !defined(X_DISPLAY_MISSING */ + + GDI_Driver->pInitialize(); - /* Create default palette */ + /* Create default palette */ - /* DR well *this* palette can't be moveable (?) */ + /* DR well *this* palette can't be moveable (?) */ { HPALETTE16 hpalette = PALETTE_Init(); if( !hpalette ) diff --git a/objects/palette.c b/objects/palette.c index 27afd1d1b25dba74e4b70235d5b6a9191ca58e76..245a60abdb78717eaa80af4c18dd305fb3227eb8 100644 --- a/objects/palette.c +++ b/objects/palette.c @@ -10,6 +10,7 @@ #include <stdlib.h> #include <string.h> + #include "gdi.h" #include "color.h" #include "palette.h" @@ -17,6 +18,8 @@ #include "debug.h" #include "wine/winuser16.h" +PALETTE_DRIVER *PALETTE_Driver = NULL; + FARPROC pfnSelectPalette = NULL; FARPROC pfnRealizePalette = NULL; @@ -134,7 +137,7 @@ HPALETTE16 WINAPI CreateHalftonePalette16( HDC16 hdc) /* [in] Handle to device context */ { return CreateHalftonePalette(hdc); - } +} /*********************************************************************** @@ -381,8 +384,9 @@ BOOL WINAPI AnimatePalette( UINT u; for( u = 0; u < NumEntries; u++ ) palPtr->logpalette.palPalEntry[u + StartIndex] = PaletteColors[u]; - COLOR_SetMapping(palPtr, StartIndex, NumEntries, - hPal != hPrimaryPalette ); + PALETTE_Driver-> + pSetMapping(palPtr, StartIndex, NumEntries, + hPal != hPrimaryPalette ); GDI_HEAP_UNLOCK( hPal ); return TRUE; } @@ -469,7 +473,7 @@ UINT WINAPI GetSystemPaletteEntries( TRACE(palette, "hdc=%04x,start=%i,count=%i\n", hdc,start,count); if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return 0; - if (!entries) return COLOR_GetSystemPaletteSize(); + if (!entries) return dc->w.devCaps->sizePalette; if (start >= dc->w.devCaps->sizePalette) { GDI_HEAP_UNLOCK( hdc ); @@ -516,9 +520,9 @@ UINT WINAPI GetNearestPaletteIndex( UINT index = 0; if( palObj ) - index = COLOR_PaletteLookupPixel( palObj->logpalette.palPalEntry, - palObj->logpalette.palNumEntries, - NULL, color, FALSE ); + index = COLOR_PaletteLookupPixel(palObj->logpalette.palPalEntry, + palObj->logpalette.palNumEntries, + NULL, color, FALSE ); TRACE(palette,"(%04x,%06lx): returning %d\n", hpalette, color, index ); GDI_HEAP_UNLOCK( hpalette ); @@ -660,9 +664,10 @@ UINT16 WINAPI GDIRealizePalette16( HDC16 hdc ) return 0; } - realized = COLOR_SetMapping(palPtr,0,palPtr->logpalette.palNumEntries, - (dc->w.hPalette != hPrimaryPalette) || - (dc->w.hPalette == STOCK_DEFAULT_PALETTE)); + realized = PALETTE_Driver-> + pSetMapping(palPtr,0,palPtr->logpalette.palNumEntries, + (dc->w.hPalette != hPrimaryPalette) || + (dc->w.hPalette == STOCK_DEFAULT_PALETTE)); GDI_HEAP_UNLOCK( dc->w.hPalette ); hLastRealizedPalette = dc->w.hPalette; } @@ -682,7 +687,6 @@ UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc ) { DC *dc; PALETTEOBJ* palPtr; - int i, index, realized = 0; TRACE(palette,"%04x\n", hdc ); @@ -707,15 +711,7 @@ UINT16 WINAPI RealizeDefaultPalette16( HDC16 hdc ) /* lookup is needed to account for SetSystemPaletteUse() stuff */ - for( i = 0; i < 20; i++ ) - { - index = COLOR_LookupSystemPixel(*(COLORREF*)(palPtr->logpalette.palPalEntry + i)); - - /* mapping is allocated in COLOR_InitPalette() */ - - if( index != palPtr->mapping[i] ) { palPtr->mapping[i]=index; realized++; } - } - return realized; + return PALETTE_Driver->pUpdateMapping(palPtr); } /*********************************************************************** @@ -798,12 +794,17 @@ UINT16 WINAPI RealizePalette16( HDC16 hDC ) UINT WINAPI RealizePalette( HDC hDC) /* [in] Handle of device context */ { - UINT realized = GDIRealizePalette16( hDC ); + DC *dc; + UINT realized; + + if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return 0; + + realized = GDIRealizePalette16( hDC ); /* do not send anything if no colors were changed */ - if( IsDCCurrentPalette16( hDC ) && realized && - !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) ) + if( IsDCCurrentPalette16( hDC ) && realized && + dc->w.devCaps->sizePalette ) { /* Send palette change notification */ @@ -811,6 +812,8 @@ UINT WINAPI RealizePalette( if( (hWnd = WindowFromDC( hDC )) ) SendMessage16( HWND_BROADCAST, WM_PALETTECHANGED, hWnd, 0L); } + + GDI_HEAP_UNLOCK( hDC ); return realized; } @@ -820,13 +823,21 @@ UINT WINAPI RealizePalette( */ INT16 WINAPI UpdateColors16( HDC16 hDC ) { - HWND hWnd = WindowFromDC( hDC ); + DC *dc; + HWND hWnd; + + if (!(dc = (DC *) GDI_GetObjPtr( hDC, DC_MAGIC ))) return 0; + + hWnd = WindowFromDC( hDC ); /* Docs say that we have to remap current drawable pixel by pixel * but it would take forever given the speed of XGet/PutPixel. */ - if (hWnd && !(COLOR_GetSystemPaletteFlags() & COLOR_VIRTUAL) ) + if (hWnd && dc->w.devCaps->sizePalette ) InvalidateRect( hWnd, NULL, FALSE ); + + GDI_HEAP_UNLOCK( hDC ); + return 0x666; } diff --git a/objects/region.c b/objects/region.c index 6a92c21f602e9ee6750481e29d4d400655a1888b..0ee4c8e1c6d45e5ca3ebed9bbef26110fff21bca 100644 --- a/objects/region.c +++ b/objects/region.c @@ -821,7 +821,6 @@ BOOL REGION_FrameRgn( HRGN hDest, HRGN hSrc, INT x, INT y ) * REGION_LPTODP * * Convert region to device co-ords for the supplied dc. - * Used by X11DRV_PaintRgn. */ BOOL REGION_LPTODP( HDC hdc, HRGN hDest, HRGN hSrc ) { diff --git a/windows/clipboard.c b/windows/clipboard.c index c7af89c26a97f9b784626e28bbccf1611d822071..75a1a1ebc3810a7cd65c09275874da9b95a82033 100644 --- a/windows/clipboard.c +++ b/windows/clipboard.c @@ -21,18 +21,14 @@ #include "xmalloc.h" #include "debug.h" -#ifndef X_DISPLAY_MISSING -extern CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver; -#else /* X_DISPLAY_MISSING */ -extern CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver; -#endif /* X_DISPLAY_MISSING */ - #define CF_REGFORMATBASE 0xC000 /************************************************************************** * internal variables */ +CLIPBOARD_DRIVER *CLIPBOARD_Driver = NULL; + static HQUEUE16 hqClipLock = 0; static BOOL bCBHasChanged = FALSE; @@ -72,19 +68,6 @@ static LPWINE_CLIPFORMAT __lookup_format( LPWINE_CLIPFORMAT lpFormat, WORD wID ) return lpFormat; } - -/************************************************************************** - * CLIPBOARD_GetDriver - */ -CLIPBOARD_DRIVER *CLIPBOARD_GetDriver() -{ -#ifndef X_DISPLAY_MISSING - return &X11DRV_CLIPBOARD_Driver; -#else /* X_DISPLAY_MISSING */ - return &TTYDRV_CLIPBOARD_Driver; -#endif /* X_DISPLAY_MISSING */ -}; - /************************************************************************** * CLIPBOARD_ResetLock */ @@ -267,7 +250,7 @@ BOOL WINAPI EmptyClipboard(void) hWndClipOwner = hWndClipWindow; - CLIPBOARD_GetDriver()->pEmptyClipboard(); + CLIPBOARD_Driver->pEmptyClipboard(); return TRUE; } @@ -310,7 +293,7 @@ HANDLE16 WINAPI SetClipboardData16( UINT16 wFormat, HANDLE16 hData ) if( (hqClipLock != GetFastQueue16()) || !lpFormat || (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) ) return 0; - CLIPBOARD_GetDriver()->pSetClipboardData(wFormat); + CLIPBOARD_Driver->pSetClipboardData(wFormat); if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 ) { @@ -358,7 +341,7 @@ HANDLE WINAPI SetClipboardData( UINT wFormat, HANDLE hData ) if( (hqClipLock != GetFastQueue16()) || !lpFormat || (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) ) return 0; - CLIPBOARD_GetDriver()->pSetClipboardData(wFormat); + CLIPBOARD_Driver->pSetClipboardData(wFormat); if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 ) { @@ -626,7 +609,7 @@ INT WINAPI CountClipboardFormats(void) TRACE(clipboard,"(void)\n"); /* FIXME: Returns BOOL32 */ - CLIPBOARD_GetDriver()->pRequestSelection(); + CLIPBOARD_Driver->pRequestSelection(); FormatCount += abs(lpFormat[CF_TEXT-1].wDataPresent - lpFormat[CF_OEMTEXT-1].wDataPresent); @@ -668,7 +651,7 @@ UINT WINAPI EnumClipboardFormats( UINT wFormat ) if( hqClipLock != GetFastQueue16() ) return 0; if( (!wFormat || wFormat == CF_TEXT || wFormat == CF_OEMTEXT) ) - CLIPBOARD_GetDriver()->pRequestSelection(); + CLIPBOARD_Driver->pRequestSelection(); if (wFormat == 0) { @@ -895,7 +878,7 @@ BOOL WINAPI IsClipboardFormatAvailable( UINT wFormat ) TRACE(clipboard,"(%04X) !\n", wFormat); if( (wFormat == CF_TEXT || wFormat == CF_OEMTEXT) ) - CLIPBOARD_GetDriver()->pRequestSelection(); + CLIPBOARD_Driver->pRequestSelection(); return CLIPBOARD_IsPresent(wFormat); } diff --git a/windows/dce.c b/windows/dce.c index ad8433cb7b34e811678b97dc543eae4d21c60c2c..2f52572b01994b6760ff2cf988d026523439d910 100644 --- a/windows/dce.c +++ b/windows/dce.c @@ -17,8 +17,7 @@ * DCX_WINDOWPAINT - BeginPaint() is in effect */ -#include "x11drv.h" - +#include "desktop.h" #include "options.h" #include "dce.h" #include "class.h" @@ -798,11 +797,9 @@ HDC WINAPI GetDCEx( HWND hwnd, HRGN hrgnClip, DWORD flags ) hrgnVisible = CreateRectRgn( 0, 0, 0, 0 ); WIN_ReleaseWndPtr(parentPtr); } - else - if ((hwnd == GetDesktopWindow()) && - (X11DRV_WND_GetXRootWindow(wndPtr) == DefaultRootWindow(display))) - hrgnVisible = CreateRectRgn( 0, 0, SYSMETRICS_CXSCREEN, - SYSMETRICS_CYSCREEN ); + else + if ((hwnd == GetDesktopWindow()) && !DESKTOP_IsSingleWindow()) + hrgnVisible = CreateRectRgn( 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN ); else { hrgnVisible = DCE_GetVisRgn( hwnd, flags, 0, 0 ); diff --git a/windows/defwnd.c b/windows/defwnd.c index 3bd9e155f69c6b4b996a6eed0190a74ea532a2d2..94f7d0c1ab75ca1fb343278ddfbf281763a8fc09 100644 --- a/windows/defwnd.c +++ b/windows/defwnd.c @@ -6,6 +6,7 @@ */ #include <string.h> + #include "win.h" #include "user.h" #include "heap.h" diff --git a/windows/display.c b/windows/display.c index 7909a69f358539be6c19c39472805ba62fde8c14..9f1b7cf08226bfddc8d5e96bb61335ab111e083b 100644 --- a/windows/display.c +++ b/windows/display.c @@ -5,29 +5,11 @@ * */ -#include "config.h" - -#include "display.h" #include "debug.h" +#include "display.h" +#include "mouse.h" #include "windef.h" - -#ifndef X_DISPLAY_MISSING -extern MOUSE_DRIVER X11DRV_MOUSE_Driver; -#else /* X_DISPLAY_MISSING */ -extern MOUSE_DRIVER TTYDRV_MOUSE_Driver; -#endif /* X_DISPLAY_MISSING */ - -/*********************************************************************** - * MOUSE_GetDriver() - */ -MOUSE_DRIVER *MOUSE_GetDriver() -{ -#ifndef X_DISPLAY_MISSING - return &X11DRV_MOUSE_Driver; -#else /* X_DISPLAY_MISSING */ - return &TTYDRV_MOUSE_Driver; -#endif /* X_DISPLAY_MISSING */ -} +#include "wine/winuser16.h" /*********************************************************************** * DISPLAY_Inquire (DISPLAY.101) @@ -45,7 +27,7 @@ WORD WINAPI DISPLAY_Inquire(LPCURSORINFO lpCursorInfo) */ VOID WINAPI DISPLAY_SetCursor( CURSORICONINFO *lpCursor ) { - MOUSE_GetDriver()->pSetCursor(lpCursor); + MOUSE_Driver->pSetCursor(lpCursor); } /*********************************************************************** @@ -53,7 +35,7 @@ VOID WINAPI DISPLAY_SetCursor( CURSORICONINFO *lpCursor ) */ VOID WINAPI DISPLAY_MoveCursor( WORD wAbsX, WORD wAbsY ) { - MOUSE_GetDriver()->pMoveCursor(wAbsX, wAbsY); + MOUSE_Driver->pMoveCursor(wAbsX, wAbsY); } /*********************************************************************** diff --git a/windows/event.c b/windows/event.c index 636cb113ec1a2e0405525084a84df66ac43615f5..5deeb86ab7924aa96b96c163f111138722e525bb 100644 --- a/windows/event.c +++ b/windows/event.c @@ -5,27 +5,11 @@ * */ -#include "config.h" - #include "message.h" -#ifndef X_DISPLAY_MISSING -extern EVENT_DRIVER X11DRV_EVENT_Driver; -#else /* X_DISPLAY_MISSING */ -extern EVENT_DRIVER TTYDRV_EVENT_Driver; -#endif /* X_DISPLAY_MISSING */ +/**********************************************************************/ -/*********************************************************************** - * EVENT_GetDriver - */ -EVENT_DRIVER *EVENT_GetDriver(void) -{ -#ifndef X_DISPLAY_MISSING - return &X11DRV_EVENT_Driver; -#else /* X_DISPLAY_MISSING */ - return &TTYDRV_EVENT_Driver; -#endif /* X_DISPLAY_MISSING */ -} +EVENT_DRIVER *EVENT_Driver = NULL; /*********************************************************************** * EVENT_Init @@ -34,7 +18,7 @@ EVENT_DRIVER *EVENT_GetDriver(void) */ BOOL EVENT_Init(void) { - return EVENT_GetDriver()->pInit(); + return EVENT_Driver->pInit(); } /*********************************************************************** @@ -42,7 +26,7 @@ BOOL EVENT_Init(void) */ void EVENT_AddIO(int fd, unsigned io_type) { - EVENT_GetDriver()->pAddIO(fd, io_type); + EVENT_Driver->pAddIO(fd, io_type); } /*********************************************************************** @@ -50,7 +34,7 @@ void EVENT_AddIO(int fd, unsigned io_type) */ void EVENT_DeleteIO(int fd, unsigned io_type) { - EVENT_GetDriver()->pDeleteIO(fd, io_type); + EVENT_Driver->pDeleteIO(fd, io_type); } /*********************************************************************** @@ -62,7 +46,7 @@ void EVENT_DeleteIO(int fd, unsigned io_type) */ BOOL EVENT_WaitNetEvent(BOOL sleep, BOOL peek) { - return EVENT_GetDriver()->pWaitNetEvent(sleep, peek); + return EVENT_Driver->pWaitNetEvent(sleep, peek); } /*********************************************************************** @@ -72,7 +56,7 @@ BOOL EVENT_WaitNetEvent(BOOL sleep, BOOL peek) */ void EVENT_Synchronize(void) { - EVENT_GetDriver()->pSynchronize(); + EVENT_Driver->pSynchronize(); } /********************************************************************** @@ -80,7 +64,7 @@ void EVENT_Synchronize(void) */ BOOL EVENT_CheckFocus(void) { - return EVENT_GetDriver()->pCheckFocus(); + return EVENT_Driver->pCheckFocus(); } /*********************************************************************** @@ -88,7 +72,7 @@ BOOL EVENT_CheckFocus(void) */ BOOL EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state) { - return EVENT_GetDriver()->pQueryPointer(posX, posY, state); + return EVENT_Driver->pQueryPointer(posX, posY, state); } @@ -99,15 +83,15 @@ BOOL EVENT_QueryPointer(DWORD *posX, DWORD *posY, DWORD *state) */ void EVENT_DummyMotionNotify(void) { - EVENT_GetDriver()->pDummyMotionNotify(); + EVENT_Driver->pDummyMotionNotify(); } /********************************************************************** - * X11DRV_EVENT_Pending + * EVENT_Pending */ BOOL EVENT_Pending() { - return EVENT_GetDriver()->pPending(); + return EVENT_Driver->pPending(); } /*********************************************************************** @@ -117,7 +101,7 @@ BOOL EVENT_Pending() */ BOOL16 WINAPI IsUserIdle16(void) { - return EVENT_GetDriver()->pIsUserIdle(); + return EVENT_Driver->pIsUserIdle(); } /*********************************************************************** @@ -129,5 +113,5 @@ BOOL16 WINAPI IsUserIdle16(void) */ void EVENT_WakeUp(void) { - EVENT_GetDriver()->pWakeUp(); + EVENT_Driver->pWakeUp(); } diff --git a/windows/keyboard.c b/windows/keyboard.c index 2ddf79327c7eb9910dfd198b8ff395523f224e3a..fa39c62e9f0f5833b880c0a1b927d07936304018 100644 --- a/windows/keyboard.c +++ b/windows/keyboard.c @@ -9,11 +9,10 @@ * */ -#include "config.h" - #include <stdlib.h> #include <string.h> #include <ctype.h> + #include "winuser.h" #include "wine/keyboard16.h" #include "win.h" @@ -25,26 +24,12 @@ #include "struct32.h" #include "winerror.h" -static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL; -LPBYTE pKeyStateTable = NULL; +/**********************************************************************/ -#ifndef X_DISPLAY_MISSING -extern KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver; -#else /* X_DISPLAY_MISSING */ -extern KEYBOARD_DRIVER TTYDRV_KEYBOARD_Driver; -#endif /* X_DISPLAY_MISSING */ +KEYBOARD_DRIVER *KEYBOARD_Driver = NULL; -/*********************************************************************** - * KEYBOARD_GetDriver - */ -KEYBOARD_DRIVER *KEYBOARD_GetDriver() -{ -#ifndef X_DISPLAY_MISSING - return &X11DRV_KEYBOARD_Driver; -#else /* X_DISPLAY_MISSING */ - return &TTYDRV_KEYBOARD_Driver; -#endif /* X_DISPLAY_MISSING */ -} +static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL; +LPBYTE pKeyStateTable = NULL; /*********************************************************************** * KEYBOARD_Inquire (KEYBOARD.1) @@ -74,7 +59,7 @@ VOID WINAPI KEYBOARD_Enable( LPKEYBD_EVENT_PROC lpKeybEventProc, /* all states to false */ memset( lpKeyState, 0, sizeof(lpKeyState) ); - if (!initDone) KEYBOARD_GetDriver()->pInit(); + if (!initDone) KEYBOARD_Driver->pInit(); initDone = TRUE; } @@ -145,7 +130,7 @@ DWORD WINAPI OemKeyScan(WORD wOemChar) WORD WINAPI VkKeyScan16(CHAR cChar) { - return KEYBOARD_GetDriver()->pVkKeyScan(cChar); + return KEYBOARD_Driver->pVkKeyScan(cChar); } /****************************************************************************** @@ -178,7 +163,7 @@ INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag) */ UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType) { - return KEYBOARD_GetDriver()->pMapVirtualKey(wCode,wMapType); + return KEYBOARD_Driver->pMapVirtualKey(wCode,wMapType); } /**************************************************************************** @@ -195,7 +180,7 @@ INT16 WINAPI GetKBCodePage16(void) */ INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize) { - return KEYBOARD_GetDriver()->pGetKeyNameText(lParam, lpBuffer, nSize); + return KEYBOARD_Driver->pGetKeyNameText(lParam, lpBuffer, nSize); } /**************************************************************************** @@ -219,8 +204,32 @@ INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize) INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState, LPVOID lpChar, UINT16 flags) { - return KEYBOARD_GetDriver()->pToAscii( + return KEYBOARD_Driver->pToAscii( virtKey, scanCode, lpKeyState, lpChar, flags ); } +/*********************************************************************** + * KEYBOARD_GetBeepActive + */ +BOOL KEYBOARD_GetBeepActive() +{ + return KEYBOARD_Driver->pGetBeepActive(); +} + +/*********************************************************************** + * KEYBOARD_SetBeepActive + */ +void KEYBOARD_SetBeepActive(BOOL bActivate) +{ + KEYBOARD_Driver->pSetBeepActive(bActivate); +} + +/*********************************************************************** + * KEYBOARD_Beep + */ +void KEYBOARD_Beep(void) +{ + KEYBOARD_Driver->pBeep(); +} + diff --git a/windows/mouse.c b/windows/mouse.c index 64f49983f9243e90a9fabaf2f00ecf395d2aa846..cfd59f1e6d730e245caeeca82885e298213a4fdd 100644 --- a/windows/mouse.c +++ b/windows/mouse.c @@ -5,17 +5,14 @@ * */ -#include <assert.h> -#include "winuser.h" -#include "gdi.h" -#include "mouse.h" #include "debug.h" -#include "debugtools.h" +#include "mouse.h" #include "monitor.h" +#include "winuser.h" /**********************************************************************/ -extern BOOL X11DRV_MOUSE_DisableWarpPointer; +MOUSE_DRIVER *MOUSE_Driver = NULL; static LPMOUSE_EVENT_PROC DefMouseEventProc = NULL; @@ -62,6 +59,7 @@ void MOUSE_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY, int width = MONITOR_GetWidth (&MONITOR_PrimaryMonitor); int height = MONITOR_GetHeight(&MONITOR_PrimaryMonitor); WINE_MOUSEEVENT wme; + BOOL bOldWarpPointer; if ( !DefMouseEventProc ) return; @@ -76,8 +74,7 @@ void MOUSE_SendEvent( DWORD mouseStatus, DWORD posX, DWORD posY, wme.time = time; wme.hWnd = hWnd; - X11DRV_MOUSE_DisableWarpPointer = TRUE; + bOldWarpPointer = MOUSE_Driver->pEnableWarpPointer(FALSE); DefMouseEventProc( mouseStatus, posX, posY, 0, (DWORD)&wme ); - X11DRV_MOUSE_DisableWarpPointer = FALSE; + MOUSE_Driver->pEnableWarpPointer(bOldWarpPointer); } - diff --git a/windows/multimon.c b/windows/multimon.c index 12ba428186562e7e5461dde7fcb03974df337500..5dc3987a81012e658f77672c93971b2ccd2ed7a0 100644 --- a/windows/multimon.c +++ b/windows/multimon.c @@ -4,9 +4,13 @@ * Copyright 1998 Turchanov Sergey */ +#include "monitor.h" #include "winbase.h" #include "winuser.h" -#include "monitor.h" + +/**********************************************************************/ + +MONITOR_DRIVER *MONITOR_Driver; /**********************************************************************/ @@ -14,12 +18,27 @@ MONITOR MONITOR_PrimaryMonitor; +/*********************************************************************** + * MONITOR_GetMonitor + */ +MONITOR *MONITOR_GetMonitor(HMONITOR hMonitor) +{ + if(hMonitor == xPRIMARY_MONITOR) + { + return &MONITOR_PrimaryMonitor; + } + else + { + return NULL; + } +} + /*********************************************************************** * MONITOR_Initialize */ void MONITOR_Initialize(MONITOR *pMonitor) { - pMonitor->pDriver->pInitialize(pMonitor); + MONITOR_Driver->pInitialize(pMonitor); } /*********************************************************************** @@ -27,7 +46,15 @@ void MONITOR_Initialize(MONITOR *pMonitor) */ void MONITOR_Finalize(MONITOR *pMonitor) { - pMonitor->pDriver->pFinalize(pMonitor); + MONITOR_Driver->pFinalize(pMonitor); +} + +/*********************************************************************** + * MONITOR_IsSingleWindow + */ +BOOL MONITOR_IsSingleWindow(MONITOR *pMonitor) +{ + return MONITOR_Driver->pIsSingleWindow(pMonitor); } /*********************************************************************** @@ -35,7 +62,7 @@ void MONITOR_Finalize(MONITOR *pMonitor) */ int MONITOR_GetWidth(MONITOR *pMonitor) { - return pMonitor->pDriver->pGetWidth(pMonitor); + return MONITOR_Driver->pGetWidth(pMonitor); } /*********************************************************************** @@ -43,7 +70,7 @@ int MONITOR_GetWidth(MONITOR *pMonitor) */ int MONITOR_GetHeight(MONITOR *pMonitor) { - return pMonitor->pDriver->pGetHeight(pMonitor); + return MONITOR_Driver->pGetHeight(pMonitor); } /*********************************************************************** @@ -51,9 +78,42 @@ int MONITOR_GetHeight(MONITOR *pMonitor) */ int MONITOR_GetDepth(MONITOR *pMonitor) { - return pMonitor->pDriver->pGetDepth(pMonitor); + return MONITOR_Driver->pGetDepth(pMonitor); +} + +/*********************************************************************** + * MONITOR_GetScreenSaveActive + */ +BOOL MONITOR_GetScreenSaveActive(MONITOR *pMonitor) +{ + return MONITOR_Driver->pGetScreenSaveActive(pMonitor); +} + +/*********************************************************************** + * MONITOR_SetScreenSaveActive + */ +void MONITOR_SetScreenSaveActive(MONITOR *pMonitor, BOOL bActivate) +{ + MONITOR_Driver->pSetScreenSaveActive(pMonitor, bActivate); +} + +/*********************************************************************** + * MONITOR_GetScreenSaveTimeout + */ +int MONITOR_GetScreenSaveTimeout(MONITOR *pMonitor) +{ + return MONITOR_Driver->pGetScreenSaveTimeout(pMonitor); +} + +/*********************************************************************** + * MONITOR_SetScreenSaveTimeout + */ +void MONITOR_SetScreenSaveTimeout(MONITOR *pMonitor, int nTimeout) +{ + MONITOR_Driver->pSetScreenSaveTimeout(pMonitor, nTimeout); } + /**********************************************************************/ HMONITOR WINAPI MonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags) diff --git a/windows/scroll.c b/windows/scroll.c index ddf6d7c9e6ac5f02fbf0892b0638256095351325..97523b0736f148020e16312043a70382d6bbf1a4 100644 --- a/windows/scroll.c +++ b/windows/scroll.c @@ -8,6 +8,7 @@ */ #include <stdlib.h> + #include "winuser.h" #include "class.h" #include "dc.h" diff --git a/windows/ttydrv/init.c b/windows/ttydrv/init.c index b7e6396abfd4c0403b40f79c3385444120d76633..7f6a15bd12cc462f1e1d55220573feddc53a953b 100644 --- a/windows/ttydrv/init.c +++ b/windows/ttydrv/init.c @@ -6,12 +6,22 @@ #include "clipboard.h" #include "desktop.h" -#include "display.h" #include "keyboard.h" #include "message.h" #include "monitor.h" +#include "mouse.h" +#include "user.h" +#include "win.h" #include "ttydrv.h" +USER_DRIVER TTYDRV_USER_Driver = +{ + TTYDRV_USER_Initialize, + TTYDRV_USER_Finalize, + TTYDRV_USER_BeginDebugging, + TTYDRV_USER_EndDebugging +}; + CLIPBOARD_DRIVER TTYDRV_CLIPBOARD_Driver = { TTYDRV_CLIPBOARD_EmptyClipboard, @@ -47,22 +57,31 @@ KEYBOARD_DRIVER TTYDRV_KEYBOARD_Driver = TTYDRV_KEYBOARD_VkKeyScan, TTYDRV_KEYBOARD_MapVirtualKey, TTYDRV_KEYBOARD_GetKeyNameText, - TTYDRV_KEYBOARD_ToAscii + TTYDRV_KEYBOARD_ToAscii, + TTYDRV_KEYBOARD_GetBeepActive, + TTYDRV_KEYBOARD_SetBeepActive, + TTYDRV_KEYBOARD_Beep }; MONITOR_DRIVER TTYDRV_MONITOR_Driver = { TTYDRV_MONITOR_Initialize, TTYDRV_MONITOR_Finalize, + TTYDRV_MONITOR_IsSingleWindow, TTYDRV_MONITOR_GetWidth, TTYDRV_MONITOR_GetHeight, - TTYDRV_MONITOR_GetDepth + TTYDRV_MONITOR_GetDepth, + TTYDRV_MONITOR_GetScreenSaveActive, + TTYDRV_MONITOR_SetScreenSaveActive, + TTYDRV_MONITOR_GetScreenSaveTimeout, + TTYDRV_MONITOR_SetScreenSaveTimeout }; MOUSE_DRIVER TTYDRV_MOUSE_Driver = { TTYDRV_MOUSE_SetCursor, - TTYDRV_MOUSE_MoveCursor + TTYDRV_MOUSE_MoveCursor, + TTYDRV_MOUSE_EnableWarpPointer }; WND_DRIVER TTYDRV_WND_Driver = diff --git a/windows/ttydrv/keyboard.c b/windows/ttydrv/keyboard.c index a6a1f6f770d43ff12f839b5393c59365cc8e2341..8010b795c41f76d9058e5a2e12cbc342279f25ea 100644 --- a/windows/ttydrv/keyboard.c +++ b/windows/ttydrv/keyboard.c @@ -53,6 +53,27 @@ INT16 TTYDRV_KEYBOARD_ToAscii( return 0; } +/*********************************************************************** + * TTYDRV_KEYBOARD_GetBeepActive + */ +BOOL TTYDRV_KEYBOARD_GetBeepActive() +{ + return FALSE; +} + +/*********************************************************************** + * TTYDRV_KEYBOARD_SetBeepActive + */ +void TTYDRV_KEYBOARD_SetBeepActive(BOOL bActivate) +{ +} + +/*********************************************************************** + * TTYDRV_KEYBOARD_Beep + */ +void TTYDRV_KEYBOARD_Beep() +{ +} diff --git a/windows/ttydrv/main.c b/windows/ttydrv/main.c index 88e39b8f32bc881f0916ae88af169e0e1f775a2c..b3985852742b0640dd636e0fc9c3b880223c0558 100644 --- a/windows/ttydrv/main.c +++ b/windows/ttydrv/main.c @@ -5,46 +5,50 @@ * */ +#include "clipboard.h" +#include "desktop.h" +#include "message.h" +#include "keyboard.h" +#include "monitor.h" +#include "mouse.h" #include "ttydrv.h" +#include "win.h" /*********************************************************************** - * TTYDRV_MAIN_Initialize + * TTYDRV_USER_Initialize */ -void TTYDRV_MAIN_Initialize() +BOOL TTYDRV_USER_Initialize(void) { -} + CLIPBOARD_Driver = &TTYDRV_CLIPBOARD_Driver; + DESKTOP_Driver = &TTYDRV_DESKTOP_Driver; + EVENT_Driver = &TTYDRV_EVENT_Driver; + KEYBOARD_Driver = &TTYDRV_KEYBOARD_Driver; + MONITOR_Driver = &TTYDRV_MONITOR_Driver; + MOUSE_Driver = &TTYDRV_MOUSE_Driver; + WND_Driver = &TTYDRV_WND_Driver; -/*********************************************************************** - * TTYDRV_MAIN_Finalize - */ -void TTYDRV_MAIN_Finalize() -{ + return TRUE; } /*********************************************************************** - * TTYDRV_MAIN_ParseOptions + * TTYDRV_USER_Finalize */ -void TTYDRV_MAIN_ParseOptions(int *argc, char *argv[]) +void TTYDRV_USER_Finalize(void) { } -/*********************************************************************** - * TTYDRV_MAIN_Create +/************************************************************************** + * TTYDRV_USER_BeginDebugging */ -void TTYDRV_MAIN_Create() +void TTYDRV_USER_BeginDebugging(void) { } -/*********************************************************************** - * TTYDRV_MAIN_SaveSetup +/************************************************************************** + * TTYDRV_USER_EndDebugging */ -void TTYDRV_MAIN_SaveSetup() +void TTYDRV_USER_EndDebugging(void) { } -/*********************************************************************** - * TTYDRV_MAIN_RestoreSetup - */ -void TTYDRV_MAIN_RestoreSetup() -{ -} + diff --git a/windows/ttydrv/monitor.c b/windows/ttydrv/monitor.c index 469330a6dc58740e136cb68d475758a68b9b5208..bf5297c449dd941342bae222edee0347410c3969 100644 --- a/windows/ttydrv/monitor.c +++ b/windows/ttydrv/monitor.c @@ -33,6 +33,14 @@ void TTYDRV_MONITOR_Finalize(MONITOR *pMonitor) HeapFree(SystemHeap, 0, pMonitor->pDriverData); } +/*********************************************************************** + * TTYDRV_MONITOR_IsSingleWindow + */ +BOOL TTYDRV_MONITOR_IsSingleWindow(MONITOR *pMonitor) +{ + return TRUE; +} + /*********************************************************************** * TTYDRV_MONITOR_GetWidth * @@ -71,3 +79,42 @@ int TTYDRV_MONITOR_GetDepth(MONITOR *pMonitor) return pTTYMonitor->depth; } + +/*********************************************************************** + * TTYDRV_MONITOR_GetScreenSaveActive + * + * Returns the active status of the screen saver + */ +BOOL TTYDRV_MONITOR_GetScreenSaveActive(MONITOR *pMonitor) +{ + return FALSE; +} + +/*********************************************************************** + * TTYDRV_MONITOR_SetScreenSaveActive + * + * Activate/Deactivate the screen saver + */ +void TTYDRV_MONITOR_SetScreenSaveActive(MONITOR *pMonitor, BOOL bActivate) +{ +} + +/*********************************************************************** + * TTYDRV_MONITOR_GetScreenSaveTimeout + * + * Return the screen saver timeout + */ +int TTYDRV_MONITOR_GetScreenSaveTimeout(MONITOR *pMonitor) +{ + return 0; +} + +/*********************************************************************** + * TTYDRV_MONITOR_SetScreenSaveTimeout + * + * Set the screen saver timeout + */ +void TTYDRV_MONITOR_SetScreenSaveTimeout( + MONITOR *pMonitor, int nTimeout) +{ +} diff --git a/windows/ttydrv/mouse.c b/windows/ttydrv/mouse.c index fba316d8d8bcddc534382a6d68f5b000add2d6b6..9ea016e4a2534d7ed48e05ab266598bb6fb3843f 100644 --- a/windows/ttydrv/mouse.c +++ b/windows/ttydrv/mouse.c @@ -19,3 +19,11 @@ void TTYDRV_MOUSE_SetCursor( CURSORICONINFO *lpCursor ) void TTYDRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY) { } + +/*********************************************************************** + * TTYDRV_MOUSE_EnableWarpPointer + */ +BOOL TTYDRV_MOUSE_EnableWarpPointer(BOOL bEnable) +{ + return TRUE; +} diff --git a/windows/ttydrv/wnd.c b/windows/ttydrv/wnd.c index 7085ac9ef2a64a3786583ed8ba9af057d5de7dbb..e4880372a72a27e6041a600932ecfdd5bb199bc4 100644 --- a/windows/ttydrv/wnd.c +++ b/windows/ttydrv/wnd.c @@ -48,7 +48,7 @@ BOOL TTYDRV_WND_DestroyWindow(WND *wndPtr) } /***************************************************************** - * X11DRV_WND_SetParent + * TTYDRV_WND_SetParent */ WND *TTYDRV_WND_SetParent(WND *wndPtr, WND *pWndParent) { @@ -64,8 +64,6 @@ void TTYDRV_WND_ForceWindowRaise(WND *wndPtr) /*********************************************************************** * WINPOS_SetXWindowPos - * - * SetWindowPos() for an X window. Used by the real SetWindowPos(). */ void TTYDRV_WND_SetWindowPos(WND *wndPtr, const WINDOWPOS *winpos, BOOL bSMC_SETXPOS) { @@ -131,4 +129,3 @@ BOOL TTYDRV_WND_IsSelfClipping(WND *wndPtr) { return FALSE; } - diff --git a/windows/win.c b/windows/win.c index e2ea887bab3353f5aff044d85e19a9f5af2affd1..402319de317ea4bdfe9157d8fa30c6132f2b1de8 100644 --- a/windows/win.c +++ b/windows/win.c @@ -4,8 +4,6 @@ * Copyright 1993, 1994 Alexandre Julliard */ -#include "config.h" - #include <stdlib.h> #include <string.h> #include "wine/winbase16.h" @@ -36,13 +34,9 @@ #include "local.h" #include "desktop.h" -#ifndef X_DISPLAY_MISSING -extern DESKTOP_DRIVER X11DRV_DESKTOP_Driver; -extern WND_DRIVER X11DRV_WND_Driver; -#else /* X_DISPLAY_MISSING */ -extern DESKTOP_DRIVER TTYDRV_DESKTOP_Driver; -extern WND_DRIVER TTYDRV_WND_Driver; -#endif /* X_DISPLAY_MISSING */ +/**********************************************************************/ + +WND_DRIVER *WND_Driver = NULL; /* Desktop window */ static WND *pWndDesktop = NULL; @@ -624,13 +618,8 @@ BOOL WIN_CreateDesktopWindow(void) pWndDesktop = (WND *) USER_HEAP_LIN_ADDR( hwndDesktop ); pDesktop = (DESKTOP *) pWndDesktop->wExtra; -#ifndef X_DISPLAY_MISSING - pDesktop->pDriver = &X11DRV_DESKTOP_Driver; - pWndDesktop->pDriver = &X11DRV_WND_Driver; -#else /* X_DISPLAY_MISSING */ - pDesktop->pDriver = &TTYDRV_DESKTOP_Driver; - pWndDesktop->pDriver = &TTYDRV_WND_Driver; -#endif /* X_DISPLAY_MISSING */ + pDesktop->pDriver = DESKTOP_Driver; + pWndDesktop->pDriver = WND_Driver; pDesktop->pDriver->pInitialize(pDesktop); pWndDesktop->pDriver->pInitialize(pWndDesktop); @@ -1179,7 +1168,7 @@ static void WIN_SendDestroyMsg( WND* pWnd ) WIN_CheckFocus(pWnd); if( CARET_GetHwnd() == pWnd->hwndSelf ) DestroyCaret(); - CLIPBOARD_GetDriver()->pResetOwner( pWnd, TRUE ); + CLIPBOARD_Driver->pResetOwner( pWnd, TRUE ); /* * Send the WM_DESTROY to the window. @@ -1320,7 +1309,7 @@ BOOL WINAPI DestroyWindow( HWND hwnd ) } } - CLIPBOARD_GetDriver()->pResetOwner( wndPtr, FALSE ); /* before the window is unmapped */ + CLIPBOARD_Driver->pResetOwner( wndPtr, FALSE ); /* before the window is unmapped */ /* Hide the window */ diff --git a/windows/winpos.c b/windows/winpos.c index 99399c05c03ffa5a1b0159f7a3d71bfe51b280da..aadcd074aded9863ae6cbe8d920b54a1222f750c 100644 --- a/windows/winpos.c +++ b/windows/winpos.c @@ -5,8 +5,6 @@ * 1995, 1996, 1999 Alex Korobka */ -#include "x11drv.h" - #include <string.h> #include "sysmetrics.h" #include "heap.h" diff --git a/windows/x11drv/event.c b/windows/x11drv/event.c index e1bf6da3623ed0c38d9e87964419b8ab410e49b9..106903a710fe034ba69bd21393d09640fb01bed7 100644 --- a/windows/x11drv/event.c +++ b/windows/x11drv/event.c @@ -1156,7 +1156,10 @@ static void EVENT_DropFromOffiX( WND *pWnd, XClientMessageEvent *event ) unsigned char* p_data = NULL; union { Atom atom_aux; - POINT pt_aux; + struct { + int x; + int y; + } pt_aux; int i; } u; int x, y; @@ -1278,7 +1281,6 @@ static void EVENT_DropURLs( WND *pWnd, XClientMessageEvent *event ) int x, y, drop32 = FALSE ; union { Atom atom_aux; - POINT pt_aux; int i; Window w_aux; } u; /* unused */ @@ -1456,7 +1458,7 @@ void EVENT_EnterNotify( WND *pWnd, XCrossingEvent *event ) { if( !Options.managed && X11DRV_GetXRootWindow() == DefaultRootWindow(display) && (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE) && GetFocus() ) - TSXInstallColormap( display, X11DRV_COLOR_GetColormap() ); + TSXInstallColormap( display, X11DRV_PALETTE_GetColormap() ); } #endif diff --git a/windows/x11drv/init.c b/windows/x11drv/init.c index ead55706eda7834899f54b49a861d3ce959b5b06..d7a59e1e6a8933912c11f47f4c83bb8eb3e9053d 100644 --- a/windows/x11drv/init.c +++ b/windows/x11drv/init.c @@ -10,13 +10,22 @@ #include "clipboard.h" #include "desktop.h" -#include "display.h" #include "keyboard.h" #include "message.h" #include "monitor.h" +#include "mouse.h" +#include "user.h" #include "win.h" #include "x11drv.h" +USER_DRIVER X11DRV_USER_Driver = +{ + X11DRV_USER_Initialize, + X11DRV_USER_Finalize, + X11DRV_USER_BeginDebugging, + X11DRV_USER_EndDebugging +}; + CLIPBOARD_DRIVER X11DRV_CLIPBOARD_Driver = { X11DRV_CLIPBOARD_EmptyClipboard, @@ -52,22 +61,31 @@ KEYBOARD_DRIVER X11DRV_KEYBOARD_Driver = X11DRV_KEYBOARD_VkKeyScan, X11DRV_KEYBOARD_MapVirtualKey, X11DRV_KEYBOARD_GetKeyNameText, - X11DRV_KEYBOARD_ToAscii + X11DRV_KEYBOARD_ToAscii, + X11DRV_KEYBOARD_GetBeepActive, + X11DRV_KEYBOARD_SetBeepActive, + X11DRV_KEYBOARD_Beep }; MONITOR_DRIVER X11DRV_MONITOR_Driver = { X11DRV_MONITOR_Initialize, X11DRV_MONITOR_Finalize, + X11DRV_MONITOR_IsSingleWindow, X11DRV_MONITOR_GetWidth, X11DRV_MONITOR_GetHeight, - X11DRV_MONITOR_GetDepth + X11DRV_MONITOR_GetDepth, + X11DRV_MONITOR_GetScreenSaveActive, + X11DRV_MONITOR_SetScreenSaveActive, + X11DRV_MONITOR_GetScreenSaveTimeout, + X11DRV_MONITOR_SetScreenSaveTimeout }; MOUSE_DRIVER X11DRV_MOUSE_Driver = { X11DRV_MOUSE_SetCursor, - X11DRV_MOUSE_MoveCursor + X11DRV_MOUSE_MoveCursor, + X11DRV_MOUSE_EnableWarpPointer }; WND_DRIVER X11DRV_WND_Driver = diff --git a/windows/x11drv/keyboard.c b/windows/x11drv/keyboard.c index baabca736a535497b4a41f037eac847f125e8966..3f011edc13847a5615728d523e5cc3fdc63dff2b 100644 --- a/windows/x11drv/keyboard.c +++ b/windows/x11drv/keyboard.c @@ -1144,6 +1144,40 @@ INT16 X11DRV_KEYBOARD_ToAscii( return ret; } -#endif /* !defined(X_DISPLAY_MISSING) */ +/*********************************************************************** + * X11DRV_KEYBOARD_GetBeepActive + */ +BOOL X11DRV_KEYBOARD_GetBeepActive() +{ + XKeyboardState keyboard_state; + + TSXGetKeyboardControl(display, &keyboard_state); + + return keyboard_state.bell_percent != 0; +} + +/*********************************************************************** + * X11DRV_KEYBOARD_SetBeepActive + */ +void X11DRV_KEYBOARD_SetBeepActive(BOOL bActivate) +{ + XKeyboardControl keyboard_value; + + if(bActivate) + keyboard_value.bell_percent = -1; + else + keyboard_value.bell_percent = 0; + + TSXChangeKeyboardControl(display, KBBellPercent, &keyboard_value); +} + +/*********************************************************************** + * X11DRV_KEYBOARD_Beep + */ +void X11DRV_KEYBOARD_Beep() +{ + TSXBell(display, 0); +} +#endif /* !defined(X_DISPLAY_MISSING) */ diff --git a/windows/x11drv/main.c b/windows/x11drv/main.c index 9d2a74e018cee6ac2628bc1dfdc22525a2a8cf6b..d5cc1fa9410ec614aeea1ec840e27125de4c123b 100644 --- a/windows/x11drv/main.c +++ b/windows/x11drv/main.c @@ -18,17 +18,30 @@ #include <stdlib.h> #include <string.h> #include <unistd.h> + +#include "clipboard.h" #include "console.h" #include "debug.h" #include "desktop.h" +#include "keyboard.h" #include "main.h" +#include "message.h" #include "monitor.h" +#include "mouse.h" #include "options.h" #include "win.h" #include "windef.h" #include "x11drv.h" #include "xmalloc.h" #include "version.h" +#include "win.h" + +/**********************************************************************/ + +void X11DRV_USER_ParseOptions(int *argc, char *argv[]); +void X11DRV_USER_Create(void); +void X11DRV_USER_SaveSetup(void); +void X11DRV_USER_RestoreSetup(void); /**********************************************************************/ @@ -89,10 +102,18 @@ Window X11DRV_GetXRootWindow() } /*********************************************************************** - * X11DRV_MAIN_Initialize + * X11DRV_USER_Initialize */ -void X11DRV_MAIN_Initialize() +BOOL X11DRV_USER_Initialize(void) { + CLIPBOARD_Driver = &X11DRV_CLIPBOARD_Driver; + DESKTOP_Driver = &X11DRV_DESKTOP_Driver; + EVENT_Driver = &X11DRV_EVENT_Driver; + KEYBOARD_Driver = &X11DRV_KEYBOARD_Driver; + MONITOR_Driver = &X11DRV_MONITOR_Driver; + MOUSE_Driver = &X11DRV_MOUSE_Driver; + WND_Driver = &X11DRV_WND_Driver; + /* We need this before calling any Xlib function */ InitializeCriticalSection( &X11DRV_CritSection ); MakeCriticalSectionGlobal( &X11DRV_CritSection ); @@ -100,22 +121,43 @@ void X11DRV_MAIN_Initialize() TSXrmInitialize(); putenv("XKB_DISABLE="); /* Disable XKB extension if present. */ + + X11DRV_USER_ParseOptions( Options.argc, Options.argv ); + X11DRV_USER_Create(); + X11DRV_USER_SaveSetup(); } /*********************************************************************** - * X11DRV_MAIN_Finalize + * X11DRV_USER_Finalize + */ +void X11DRV_USER_Finalize(void) +{ + X11DRV_USER_RestoreSetup(); +} + +/************************************************************************** + * X11DRV_USER_BeginDebugging + */ +void X11DRV_USER_BeginDebugging(void) +{ + TSXUngrabServer(display); + TSXFlush(display); +} + +/************************************************************************** + * X11DRV_USER_EndDebugging */ -void X11DRV_MAIN_Finalize() +void X11DRV_USER_EndDebugging(void) { } /*********************************************************************** - * X11DRV_MAIN_GetResource + * X11DRV_USER_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 ) +static int X11DRV_USER_GetResource( XrmDatabase db, char *name, XrmValue *value ) { char *buff_instance, *buff_class; char *dummy; @@ -135,10 +177,10 @@ static int X11DRV_MAIN_GetResource( XrmDatabase db, char *name, XrmValue *value } /*********************************************************************** - * X11DRV_MAIN_ParseOptions + * X11DRV_USER_ParseOptions * Parse command line options and open display. */ -void X11DRV_MAIN_ParseOptions(int *argc, char *argv[]) +void X11DRV_USER_ParseOptions(int *argc, char *argv[]) { int i; char *display_name = NULL; @@ -155,7 +197,7 @@ void X11DRV_MAIN_ParseOptions(int *argc, char *argv[]) /* Open display */ if (display_name == NULL && - X11DRV_MAIN_GetResource( db, ".display", &value )) display_name = value.addr; + X11DRV_USER_GetResource( db, ".display", &value )) display_name = value.addr; if (!(display = TSXOpenDisplay( display_name ))) { @@ -184,35 +226,35 @@ void X11DRV_MAIN_ParseOptions(int *argc, char *argv[]) Options.programName, argc, argv ); /* Get all options */ - if (X11DRV_MAIN_GetResource( db, ".iconic", &value )) + if (X11DRV_USER_GetResource( db, ".iconic", &value )) Options.cmdShow = SW_SHOWMINIMIZED; - if (X11DRV_MAIN_GetResource( db, ".privatemap", &value )) + if (X11DRV_USER_GetResource( db, ".privatemap", &value )) Options.usePrivateMap = TRUE; - if (X11DRV_MAIN_GetResource( db, ".fixedmap", &value )) + if (X11DRV_USER_GetResource( db, ".fixedmap", &value )) Options.useFixedMap = TRUE; - if (X11DRV_MAIN_GetResource( db, ".synchronous", &value )) + if (X11DRV_USER_GetResource( db, ".synchronous", &value )) Options.synchronous = TRUE; - if (X11DRV_MAIN_GetResource( db, ".backingstore", &value )) + if (X11DRV_USER_GetResource( db, ".backingstore", &value )) Options.backingstore = TRUE; - if (X11DRV_MAIN_GetResource( db, ".debug", &value )) + if (X11DRV_USER_GetResource( db, ".debug", &value )) Options.debug = TRUE; - if (X11DRV_MAIN_GetResource( db, ".failreadonly", &value )) + if (X11DRV_USER_GetResource( db, ".failreadonly", &value )) Options.failReadOnly = TRUE; - if (X11DRV_MAIN_GetResource( db, ".perfect", &value )) + if (X11DRV_USER_GetResource( db, ".perfect", &value )) Options.perfectGraphics = TRUE; - if (X11DRV_MAIN_GetResource( db, ".depth", &value)) + if (X11DRV_USER_GetResource( db, ".depth", &value)) Options.screenDepth = atoi( value.addr ); - if (X11DRV_MAIN_GetResource( db, ".desktop", &value)) + if (X11DRV_USER_GetResource( db, ".desktop", &value)) Options.desktopGeometry = value.addr; - if (X11DRV_MAIN_GetResource( db, ".language", &value)) + if (X11DRV_USER_GetResource( db, ".language", &value)) MAIN_ParseLanguageOption( (char *)value.addr ); - if (X11DRV_MAIN_GetResource( db, ".managed", &value)) + if (X11DRV_USER_GetResource( db, ".managed", &value)) Options.managed = TRUE; - if (X11DRV_MAIN_GetResource( db, ".mode", &value)) + if (X11DRV_USER_GetResource( db, ".mode", &value)) MAIN_ParseModeOption( (char *)value.addr ); - if (X11DRV_MAIN_GetResource( db, ".debugoptions", &value)) + if (X11DRV_USER_GetResource( db, ".debugoptions", &value)) MAIN_ParseDebugOptions((char*)value.addr); - if (X11DRV_MAIN_GetResource( db, ".debugmsg", &value)) + if (X11DRV_USER_GetResource( db, ".debugmsg", &value)) { #ifndef DEBUG_RUNTIME MSG("%s: Option \"-debugmsg\" not implemented.\n" \ @@ -224,7 +266,7 @@ void X11DRV_MAIN_ParseOptions(int *argc, char *argv[]) #endif } - if (X11DRV_MAIN_GetResource( db, ".dll", &value)) + if (X11DRV_USER_GetResource( db, ".dll", &value)) { if (Options.dllFlags) { @@ -236,35 +278,35 @@ void X11DRV_MAIN_ParseOptions(int *argc, char *argv[]) else Options.dllFlags = xstrdup((char *)value.addr); } - if (X11DRV_MAIN_GetResource( db, ".winver", &value)) + if (X11DRV_USER_GetResource( db, ".winver", &value)) VERSION_ParseWinVersion( (char*)value.addr ); - if (X11DRV_MAIN_GetResource( db, ".dosver", &value)) + if (X11DRV_USER_GetResource( db, ".dosver", &value)) VERSION_ParseDosVersion( (char*)value.addr ); - if (X11DRV_MAIN_GetResource( db, ".config", &value)) + if (X11DRV_USER_GetResource( db, ".config", &value)) Options.configFileName = xstrdup((char *)value.addr); - if (X11DRV_MAIN_GetResource( db, ".nodga", &value)) + if (X11DRV_USER_GetResource( db, ".nodga", &value)) Options.noDGA = TRUE; - if (X11DRV_MAIN_GetResource( db, ".console", &value)) + if (X11DRV_USER_GetResource( db, ".console", &value)) driver.driver_list = xstrdup((char *)value.addr); else driver.driver_list = CONSOLE_DEFAULT_DRIVER; } /*********************************************************************** - * X11DRV_MAIN_ErrorHandler + * X11DRV_USER_ErrorHandler */ -static int X11DRV_MAIN_ErrorHandler(Display *display, XErrorEvent *error_evt) +static int X11DRV_USER_ErrorHandler(Display *display, XErrorEvent *error_evt) { kill( getpid(), SIGHUP ); /* force an entry in the debugger */ return 0; } /*********************************************************************** - * X11DRV_MAIN_Create + * X11DRV_USER_Create */ -void X11DRV_MAIN_Create() +void X11DRV_USER_Create() { - if (Options.synchronous) XSetErrorHandler( X11DRV_MAIN_ErrorHandler ); + if (Options.synchronous) XSetErrorHandler( X11DRV_USER_ErrorHandler ); if (Options.desktopGeometry && Options.managed) { @@ -279,17 +321,17 @@ void X11DRV_MAIN_Create() } /*********************************************************************** - * X11DRV_MAIN_SaveSetup + * X11DRV_USER_SaveSetup */ -void X11DRV_MAIN_SaveSetup() +void X11DRV_USER_SaveSetup() { TSXGetKeyboardControl(display, &X11DRV_XKeyboardState); } /*********************************************************************** - * X11DRV_MAIN_RestoreSetup + * X11DRV_USER_RestoreSetup */ -void X11DRV_MAIN_RestoreSetup() +void X11DRV_USER_RestoreSetup() { XKeyboardControl keyboard_value; diff --git a/windows/x11drv/monitor.c b/windows/x11drv/monitor.c index 97e30806b0fcc538944d349a96e4cb6a1acac962..debec810d0a3021f4e1259ec535fca52791ab53d 100644 --- a/windows/x11drv/monitor.c +++ b/windows/x11drv/monitor.c @@ -183,6 +183,17 @@ void X11DRV_MONITOR_Finalize(MONITOR *pMonitor) HeapFree(SystemHeap, 0, pMonitor->pDriverData); } +/*********************************************************************** + * X11DRV_MONITOR_IsSingleWindow + */ +BOOL X11DRV_MONITOR_IsSingleWindow(MONITOR *pMonitor) +{ + X11DRV_MONITOR_DATA *pX11Monitor = + (X11DRV_MONITOR_DATA *) pMonitor->pDriverData; + + return (pX11Monitor->rootWindow != DefaultRootWindow(display)); +} + /*********************************************************************** * X11DRV_MONITOR_GetWidth * @@ -222,6 +233,53 @@ int X11DRV_MONITOR_GetDepth(MONITOR *pMonitor) return pX11Monitor->depth; } -#endif /* X_DISPLAY_MISSING */ +/*********************************************************************** + * X11DRV_MONITOR_GetScreenSaveActive + * + * Returns the active status of the screen saver + */ +BOOL X11DRV_MONITOR_GetScreenSaveActive(MONITOR *pMonitor) +{ + int timeout, temp; + TSXGetScreenSaver(display, &timeout, &temp, &temp, &temp); + return timeout!=NULL; +} +/*********************************************************************** + * X11DRV_MONITOR_SetScreenSaveActive + * + * Activate/Deactivate the screen saver + */ +void X11DRV_MONITOR_SetScreenSaveActive(MONITOR *pMonitor, BOOL bActivate) +{ + if(bActivate) + TSXActivateScreenSaver(display); + else + TSXResetScreenSaver(display); +} + +/*********************************************************************** + * X11DRV_MONITOR_GetScreenSaveTimeout + * + * Return the screen saver timeout + */ +int X11DRV_MONITOR_GetScreenSaveTimeout(MONITOR *pMonitor) +{ + int timeout, temp; + TSXGetScreenSaver(display, &timeout, &temp, &temp, &temp); + return timeout; +} + +/*********************************************************************** + * X11DRV_MONITOR_SetScreenSaveTimeout + * + * Set the screen saver timeout + */ +void X11DRV_MONITOR_SetScreenSaveTimeout( + MONITOR *pMonitor, int nTimeout) +{ + TSXSetScreenSaver(display, nTimeout, 60, + DefaultBlanking, DefaultExposures); +} +#endif /* X_DISPLAY_MISSING */ diff --git a/windows/x11drv/mouse.c b/windows/x11drv/mouse.c index 7eb8f7fa400a0f8418f73ce5e2df5a782ab7af5c..19eaac21b3bab0a638593cb5a75a2172c819f595 100644 --- a/windows/x11drv/mouse.c +++ b/windows/x11drv/mouse.c @@ -12,7 +12,7 @@ #include "callback.h" #include "debug.h" -#include "display.h" +#include "mouse.h" #include "win.h" #include "windef.h" #include "x11drv.h" @@ -21,7 +21,7 @@ Cursor X11DRV_MOUSE_XCursor = None; /* Current X cursor */ -BOOL X11DRV_MOUSE_DisableWarpPointer = FALSE; /* hack; see DISPLAY_MoveCursor */ +static BOOL X11DRV_MOUSE_WarpPointer = FALSE; /* hack; see DISPLAY_MoveCursor */ /*********************************************************************** * X11DRV_MOUSE_DoSetCursor @@ -203,7 +203,7 @@ void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY) int rootX, rootY, winX, winY; unsigned int xstate; - if (X11DRV_MOUSE_DisableWarpPointer) return; + if (!X11DRV_MOUSE_WarpPointer) return; if (!TSXQueryPointer( display, X11DRV_GetXRootWindow(), &root, &child, &rootX, &rootY, &winX, &winY, &xstate )) @@ -218,4 +218,16 @@ void X11DRV_MOUSE_MoveCursor(WORD wAbsX, WORD wAbsY) 0, 0, 0, 0, wAbsX, wAbsY ); } +/*********************************************************************** + * X11DRV_MOUSE_EnableWarpPointer + */ +BOOL X11DRV_MOUSE_EnableWarpPointer(BOOL bEnable) +{ + BOOL bOldEnable = X11DRV_MOUSE_WarpPointer; + + X11DRV_MOUSE_WarpPointer = bEnable; + + return bOldEnable; +} + #endif /* !defined(X_DISPLAY_MISSING) */ diff --git a/windows/x11drv/wnd.c b/windows/x11drv/wnd.c index cb5f474882caa2a0bfb6288c892613687c9efda4..a877dec0bb5c831af8439cd28e2f25c4e1d7f2af 100644 --- a/windows/x11drv/wnd.c +++ b/windows/x11drv/wnd.c @@ -196,7 +196,7 @@ BOOL X11DRV_WND_CreateWindow(WND *wndPtr, CLASS *classPtr, CREATESTRUCTA *cs, BO wndPtr->flags |= WIN_NATIVE; win_attr.bit_gravity = BGNorthWest; - win_attr.colormap = X11DRV_COLOR_GetColormap(); + win_attr.colormap = X11DRV_PALETTE_PaletteXColormap; win_attr.backing_store = Options.backingstore ? WhenMapped : NotUseful; win_attr.save_under = ((classPtr->style & CS_SAVEBITS) != 0); win_attr.cursor = X11DRV_MOUSE_XCursor; @@ -548,8 +548,8 @@ void X11DRV_WND_SetFocus(WND *wndPtr) if (!hwnd) /* If setting the focus to 0, uninstall the colormap */ { - if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE) - TSXUninstallColormap( display, X11DRV_COLOR_GetColormap() ); + if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE) + TSXUninstallColormap( display, X11DRV_PALETTE_PaletteXColormap ); return; } @@ -561,8 +561,8 @@ void X11DRV_WND_SetFocus(WND *wndPtr) return; /* If window is not viewable, don't change anything */ TSXSetInputFocus( display, win, RevertToParent, CurrentTime ); - if (COLOR_GetSystemPaletteFlags() & COLOR_PRIVATE) - TSXInstallColormap( display, X11DRV_COLOR_GetColormap() ); + if (X11DRV_PALETTE_PaletteFlags & X11DRV_PALETTE_PRIVATE) + TSXInstallColormap( display, X11DRV_PALETTE_PaletteXColormap ); EVENT_Synchronize(); } @@ -716,10 +716,7 @@ BOOL X11DRV_WND_SetHostAttr(WND* wnd, INT ha, INT value) */ BOOL X11DRV_WND_IsSelfClipping(WND *wndPtr) { - if( X11DRV_WND_GetXWindow(wndPtr) ) - return TRUE; /* X itself will do the clipping */ - - return FALSE; + return X11DRV_WND_GetXWindow(wndPtr) != None; } #endif /* !defined(X_DISPLAY_MISSING) */