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

Removed CALL_LARGE_STACK support.

This commit is contained in:
Alexandre Julliard 2001-01-15 22:30:50 +00:00
parent 16a9a2d730
commit 8efd454067
10 changed files with 145 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
dlls/x11drv/x11drv_main.c
View File

@ -22,7 +22,6 @@
#include "wine/winbase16.h"
#include "winreg.h"
#include "callback.h"
#include "debugtools.h"
#include "gdi.h"
#include "options.h"
@ -257,11 +256,6 @@ static void create_desktop( const char *geometry )
TSXMapWindow( display, root_window );
}
/* Created so that XOpenIM can be called using the 'large stack' */
static void XOpenIM_large_stack(void)
{
TSXOpenIM(display,NULL,NULL,NULL);
}
/***********************************************************************
* X11DRV process initialisation routine
@ -315,7 +309,7 @@ static void process_attach(void)
* them to work in Wine, even whith a libX11 including the dead key
* patches from Th.Quinot (http://Web.FdN.FR/~tquinot/dead-keys.en.html)
*/
CALL_LARGE_STACK( XOpenIM_large_stack, NULL );
TSXOpenIM( display, NULL, NULL, NULL);
if (Options.synchronous) XSetErrorHandler( error_handler );

93
graphics/x11drv/bitblt.c
View File

@ -13,8 +13,10 @@
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "bitmap.h"
#include "callback.h"
#include "color.h"
#include "gdi.h"
#include "metafile.h"
@ -1421,34 +1423,6 @@ static BOOL BITBLT_InternalStretchBlt( DC *dcDst, INT xDst, INT yDst,
return TRUE;
}
struct StretchBlt_params
{
DC *dcDst;
INT xDst;
INT yDst;
INT widthDst;
INT heightDst;
DC *dcSrc;
INT xSrc;
INT ySrc;
INT widthSrc;
INT heightSrc;
DWORD rop;
};
/***********************************************************************
* BITBLT_DoStretchBlt
*
* Wrapper function for BITBLT_InternalStretchBlt
* to use with CALL_LARGE_STACK.
*/
static int BITBLT_DoStretchBlt( const struct StretchBlt_params *p )
{
return (int)BITBLT_InternalStretchBlt( p->dcDst, p->xDst, p->yDst,
p->widthDst, p->heightDst,
p->dcSrc, p->xSrc, p->ySrc,
p->widthSrc, p->heightSrc, p->rop );
}
/***********************************************************************
* X11DRV_PatBlt
@ -1456,25 +1430,12 @@ static int BITBLT_DoStretchBlt( const struct StretchBlt_params *p )
BOOL X11DRV_PatBlt( DC *dc, INT left, INT top,
INT width, INT height, DWORD rop )
{
struct StretchBlt_params params;
BOOL result;
params.dcDst = dc;
params.xDst = left;
params.yDst = top;
params.widthDst = width;
params.heightDst = height;
params.dcSrc = NULL;
params.xSrc = 0;
params.ySrc = 0;
params.widthSrc = 0;
params.heightSrc = 0;
params.rop = rop;
X11DRV_LockDIBSection( dc, DIB_Status_GdiMod, FALSE );
EnterCriticalSection( &X11DRV_CritSection );
result = (BOOL)CALL_LARGE_STACK( BITBLT_DoStretchBlt, &params );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
result = BITBLT_InternalStretchBlt( dc, left, top, width, height, NULL, 0, 0, 0, 0, rop );
wine_tsx11_unlock();
X11DRV_UnlockDIBSection( dc, TRUE );
return result;
}
@ -1487,7 +1448,6 @@ BOOL X11DRV_BitBlt( DC *dcDst, INT xDst, INT yDst,
INT width, INT height, DC *dcSrc,
INT xSrc, INT ySrc, DWORD rop )
{
struct StretchBlt_params params;
BOOL result = FALSE;
INT sSrc, sDst;
RECT visRectDst, visRectSrc;
@ -1515,7 +1475,7 @@ BOOL X11DRV_BitBlt( DC *dcDst, INT xDst, INT yDst,
dcSrc, xSrc, ySrc, width, height,
&visRectSrc, &visRectDst ))
goto END;
xSrc = visRectSrc.left;
ySrc = visRectSrc.top;
xDst = visRectDst.left;
@ -1533,24 +1493,13 @@ BOOL X11DRV_BitBlt( DC *dcDst, INT xDst, INT yDst,
goto END;
}
params.dcDst = dcDst;
params.xDst = xDst;
params.yDst = yDst;
params.widthDst = width;
params.heightDst = height;
params.dcSrc = dcSrc;
params.xSrc = xSrc;
params.ySrc = ySrc;
params.widthSrc = width;
params.heightSrc = height;
params.rop = rop;
X11DRV_CoerceDIBSection( dcDst, DIB_Status_GdiMod, FALSE );
X11DRV_CoerceDIBSection( dcSrc, DIB_Status_GdiMod, FALSE );
EnterCriticalSection( &X11DRV_CritSection );
result = (BOOL)CALL_LARGE_STACK( BITBLT_DoStretchBlt, &params );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
result = BITBLT_InternalStretchBlt( dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, width, height, rop );
wine_tsx11_unlock();
END:
X11DRV_UnlockDIBSection( dcSrc, FALSE );
@ -1568,27 +1517,15 @@ BOOL X11DRV_StretchBlt( DC *dcDst, INT xDst, INT yDst,
DC *dcSrc, INT xSrc, INT ySrc,
INT widthSrc, INT heightSrc, DWORD rop )
{
struct StretchBlt_params params;
BOOL result;
params.dcDst = dcDst;
params.xDst = xDst;
params.yDst = yDst;
params.widthDst = widthDst;
params.heightDst = heightDst;
params.dcSrc = dcSrc;
params.xSrc = xSrc;
params.ySrc = ySrc;
params.widthSrc = widthSrc;
params.heightSrc = heightSrc;
params.rop = rop;
X11DRV_LockDIBSection( dcDst, DIB_Status_GdiMod, FALSE );
X11DRV_LockDIBSection( dcSrc, DIB_Status_GdiMod, FALSE );
EnterCriticalSection( &X11DRV_CritSection );
result = (BOOL)CALL_LARGE_STACK( BITBLT_DoStretchBlt, &params );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
result = BITBLT_InternalStretchBlt( dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
wine_tsx11_unlock();
X11DRV_UnlockDIBSection( dcSrc, FALSE );
X11DRV_UnlockDIBSection( dcDst, TRUE );

62
graphics/x11drv/bitmap.c
View File

@ -13,7 +13,6 @@
#include <stdio.h>
#include <stdlib.h>
#include "gdi.h"
#include "callback.h"
#include "bitmap.h"
#include "heap.h"
#include "debugtools.h"
@ -110,27 +109,6 @@ HBITMAP X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP hbitmap,
}
/***********************************************************************
* XPutImage_wrapper
*
* Wrapper to call XPutImage with CALL_LARGE_STACK.
*/
struct XPutImage_descr
{
BITMAPOBJ *bmp;
XImage *image;
INT width;
INT height;
};
static int XPutImage_wrapper( const struct XPutImage_descr *descr )
{
return XPutImage( display, (Pixmap)descr->bmp->physBitmap, BITMAP_GC(descr->bmp),
descr->image, 0, 0, 0, 0, descr->width, descr->height );
}
/****************************************************************************
*
* X11DRV_CreateBitmap
@ -189,19 +167,6 @@ BOOL X11DRV_CreateBitmap( HBITMAP hbitmap )
}
/***********************************************************************
* X11DRV_BITMAP_GetXImage
*
* Get an X image for a bitmap. For use with CALL_LARGE_STACK.
*/
XImage *X11DRV_BITMAP_GetXImage( const BITMAPOBJ *bmp )
{
return XGetImage( display, (Pixmap)bmp->physBitmap,
0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
AllPlanes, ZPixmap );
}
/***********************************************************************
* X11DRV_GetBitmapBits
*
@ -218,7 +183,7 @@ static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
TRACE("(bmp=%p, buffer=%p, count=0x%lx)\n", bmp, buffer, count);
EnterCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
/* Hack: change the bitmap height temporarily to avoid */
/* getting unnecessary bitmap rows. */
@ -226,8 +191,9 @@ static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
old_height = bmp->bitmap.bmHeight;
height = bmp->bitmap.bmHeight = count / bmp->bitmap.bmWidthBytes;
image = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
image = XGetImage( display, (Pixmap)bmp->physBitmap,
0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
AllPlanes, ZPixmap );
bmp->bitmap.bmHeight = old_height;
/* copy XImage to 16 bit padded image buffer with real bitsperpixel */
@ -322,8 +288,7 @@ static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
FIXME("Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
}
XDestroyImage( image );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
return count;
}
@ -338,7 +303,6 @@ static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
*/
static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
{
struct XPutImage_descr descr;
LONG height;
XImage *image;
LPBYTE sbuf, startline;
@ -348,14 +312,14 @@ static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
height = count / bmp->bitmap.bmWidthBytes;
EnterCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
image = XCreateImage( display, X11DRV_GetVisual(), bmp->bitmap.bmBitsPixel, ZPixmap, 0, NULL,
bmp->bitmap.bmWidth, height, 32, 0 );
if (!(image->data = (LPBYTE)malloc(image->bytes_per_line * height)))
{
WARN("No memory to create image data.\n");
XDestroyImage( image );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
return 0;
}
@ -440,16 +404,10 @@ static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
FIXME("Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
}
descr.bmp = bmp;
descr.image = image;
descr.width = bmp->bitmap.bmWidth;
descr.height = height;
CALL_LARGE_STACK( XPutImage_wrapper, &descr );
XPutImage( display, (Pixmap)bmp->physBitmap, BITMAP_GC(bmp),
image, 0, 0, 0, 0, bmp->bitmap.bmWidth, height );
XDestroyImage( image ); /* frees image->data too */
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
return count;
}

79
graphics/x11drv/dib.c
View File

@ -25,7 +25,6 @@
#include "debugtools.h"
#include "gdi.h"
#include "color.h"
#include "callback.h"
#include "selectors.h"
#include "global.h"
@ -37,6 +36,35 @@ static int ximageDepthTable[] = { 0, 0, 0, 0, 0, 0, 0 };
static int XShmErrorFlag = 0;
/* This structure holds the arguments for DIB_SetImageBits() */
typedef struct
{
struct tagDC *dc;
LPCVOID bits;
XImage *image;
PALETTEENTRY *palentry;
int lines;
DWORD infoWidth;
WORD depth;
WORD infoBpp;
WORD compression;
RGBQUAD *colorMap;
int nColorMap;
Drawable drawable;
GC gc;
int xSrc;
int ySrc;
int xDest;
int yDest;
int width;
int height;
DWORD rMask;
DWORD gMask;
DWORD bMask;
BOOL useShm;
int dibpitch;
} X11DRV_DIB_IMAGEBITS_DESCR;
/***********************************************************************
* X11DRV_DIB_Init
*/
@ -2608,13 +2636,13 @@ static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *dstbits,
*
* Transfer the bits to an X image.
* Helper function for SetDIBits() and SetDIBitsToDevice().
* The Xlib critical section must be entered before calling this function.
*/
int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
static int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
{
int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
XImage *bmpImage;
wine_tsx11_lock();
if (descr->image)
bmpImage = descr->image;
else {
@ -2624,6 +2652,7 @@ int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
if(bmpImage->data == NULL) {
ERR("Out of memory!\n");
XDestroyImage( bmpImage );
wine_tsx11_unlock();
return lines;
}
}
@ -2709,6 +2738,7 @@ int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
descr->width, descr->height );
if (!descr->image) XDestroyImage( bmpImage );
wine_tsx11_unlock();
return lines;
}
@ -2716,14 +2746,14 @@ int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
* X11DRV_DIB_GetImageBits
*
* Transfer the bits from an X image.
* The Xlib critical section must be entered before calling this function.
*/
int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
static int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
{
int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
XImage *bmpImage;
if (descr->image)
wine_tsx11_lock();
if (descr->image)
bmpImage = descr->image;
else {
bmpImage = XCreateImage( display, X11DRV_GetVisual(), descr->depth, ZPixmap, 0, NULL,
@ -2732,8 +2762,10 @@ int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
if(bmpImage->data == NULL) {
ERR("Out of memory!\n");
XDestroyImage( bmpImage );
wine_tsx11_unlock();
return lines;
} }
}
}
TRACE("XGetSubImage(%p,%ld,%d,%d,%d,%d,%ld,%d,%p,%d,%d)\n",
display, descr->drawable, descr->xSrc, descr->ySrc, descr->width,
@ -2798,6 +2830,7 @@ int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
}
if (!descr->image) XDestroyImage( bmpImage );
wine_tsx11_unlock();
return lines;
}
@ -2886,9 +2919,7 @@ INT X11DRV_SetDIBitsToDevice( DC *dc, INT xDest, INT yDest, DWORD cx,
descr.useShm = FALSE;
descr.dibpitch = ((width * descr.infoBpp + 31) &~31) / 8;
EnterCriticalSection( &X11DRV_CritSection );
result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
result = X11DRV_DIB_SetImageBits( &descr );
if (descr.infoBpp <= 8)
HeapFree(GetProcessHeap(), 0, descr.colorMap);
@ -2974,11 +3005,8 @@ INT X11DRV_DIB_SetDIBits(
descr.height = lines;
descr.useShm = FALSE;
descr.dibpitch = ((descr.infoWidth * descr.infoBpp + 31) &~31) / 8;
EnterCriticalSection( &X11DRV_CritSection );
result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
result = X11DRV_DIB_SetImageBits( &descr );
if (descr.colorMap) HeapFree(GetProcessHeap(), 0, descr.colorMap);
return result;
@ -3089,12 +3117,8 @@ INT X11DRV_DIB_GetDIBits(
descr.dibpitch = dib ? (dib->dibSection.dsBm.bmWidthBytes)
: (((descr.infoWidth * descr.infoBpp + 31) &~31) / 8);
EnterCriticalSection( &X11DRV_CritSection );
X11DRV_DIB_GetImageBits( &descr );
CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
if(info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */
info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes(
info->bmiHeader.biWidth,
@ -3201,16 +3225,12 @@ static void X11DRV_DIB_DoCopyDIBSection(BITMAPOBJ *bmp, BOOL toDIB,
if (toDIB)
{
TRACE("Copying from Pixmap to DIB bits\n");
EnterCriticalSection( &X11DRV_CritSection );
CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
X11DRV_DIB_GetImageBits( &descr );
}
else
{
TRACE("Copying from DIB bits to Pixmap\n");
EnterCriticalSection( &X11DRV_CritSection );
CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
X11DRV_DIB_SetImageBits( &descr );
}
}
@ -3699,7 +3719,7 @@ extern BOOL X11DRV_XShmCreateImage(XImage** image, int width, int height, int bp
*image = TSXShmCreateImage(display, X11DRV_GetVisual(), bpp, ZPixmap, NULL, shminfo, width, height);
if( *image != NULL )
{
EnterCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
shminfo->shmid = shmget(IPC_PRIVATE, (*image)->bytes_per_line * height,
IPC_CREAT|0700);
if( shminfo->shmid != -1 )
@ -3720,8 +3740,7 @@ extern BOOL X11DRV_XShmCreateImage(XImage** image, int width, int height, int bp
shmctl(shminfo->shmid, IPC_RMID, 0);
XSetErrorHandler(WineXHandler);
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
return TRUE; /* Success! */
}
/* An error occured */
@ -3734,7 +3753,7 @@ extern BOOL X11DRV_XShmCreateImage(XImage** image, int width, int height, int bp
}
XFlush(display);
XDestroyImage(*image);
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
}
return FALSE;
}

115
graphics/x11drv/graphics.c
View File

@ -30,7 +30,6 @@
#include "x11font.h"
#include "bitmap.h"
#include "gdi.h"
#include "callback.h"
#include "metafile.h"
#include "palette.h"
#include "color.h"
@ -124,7 +123,7 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors )
{
register int x, y;
XImage *image;
EnterCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
pixmap = XCreatePixmap( display, X11DRV_GetXRootWindow(),
8, 8, X11DRV_GetDepth() );
image = XGetImage( display, physDev->brush.pixmap, 0, 0, 8, 8,
@ -135,7 +134,7 @@ BOOL X11DRV_SetupGCForPatBlt( DC * dc, GC gc, BOOL fMapColors )
X11DRV_PALETTE_XPixelToPalette[XGetPixel( image, x, y)] );
XPutImage( display, pixmap, gc, image, 0, 0, 0, 0, 8, 8 );
XDestroyImage( image );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
val.tile = pixmap;
}
else val.tile = physDev->brush.pixmap;
@ -880,7 +879,7 @@ X11DRV_GetPixel( DC *dc, INT x, INT y )
x = dc->DCOrgX + XLPTODP( dc, x );
y = dc->DCOrgY + YLPTODP( dc, y );
EnterCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
if (dc->flags & DC_MEMORY)
{
image = XGetImage( display, physDev->drawable, x, y, 1, 1,
@ -898,8 +897,7 @@ X11DRV_GetPixel( DC *dc, INT x, INT y )
}
pixel = XGetPixel( image, 0, 0 );
XDestroyImage( image );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_unlock();
return X11DRV_PALETTE_ToLogical(pixel);
}
@ -1211,63 +1209,6 @@ static void X11DRV_InternalFloodFill(XImage *image, DC *dc,
}
/**********************************************************************
* X11DRV_DoFloodFill
*
* Main flood-fill routine.
*
* The Xlib critical section must be entered before calling this function.
*/
struct FloodFill_params
{
DC *dc;
INT x;
INT y;
COLORREF color;
UINT fillType;
};
static BOOL X11DRV_DoFloodFill( const struct FloodFill_params *params )
{
XImage *image;
RECT rect;
DC *dc = params->dc;
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
if (GetRgnBox( dc->hGCClipRgn, &rect ) == ERROR) return FALSE;
if (!(image = XGetImage( display, physDev->drawable,
rect.left,
rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
AllPlanes, ZPixmap ))) return FALSE;
if (X11DRV_SetupGCForBrush( dc ))
{
/* Update the pixmap from the DIB section */
X11DRV_LockDIBSection(dc, DIB_Status_GdiMod, FALSE);
/* ROP mode is always GXcopy for flood-fill */
XSetFunction( display, physDev->gc, GXcopy );
X11DRV_InternalFloodFill(image, dc,
XLPTODP(dc,params->x) + dc->DCOrgX - rect.left,
YLPTODP(dc,params->y) + dc->DCOrgY - rect.top,
rect.left,
rect.top,
X11DRV_PALETTE_ToPhysical( dc, params->color ),
params->fillType );
/* Update the DIBSection of the dc's bitmap */
X11DRV_UnlockDIBSection(dc, TRUE);
}
XDestroyImage( image );
return TRUE;
}
/**********************************************************************
* X11DRV_ExtFloodFill
*/
@ -1275,23 +1216,43 @@ BOOL
X11DRV_ExtFloodFill( DC *dc, INT x, INT y, COLORREF color,
UINT fillType )
{
BOOL result;
struct FloodFill_params params;
XImage *image;
RECT rect;
X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
TRACE("X11DRV_ExtFloodFill %d,%d %06lx %d\n",
x, y, color, fillType );
params.dc = dc;
params.x = x;
params.y = y;
params.color = color;
params.fillType = fillType;
TRACE("X11DRV_ExtFloodFill %d,%d %06lx %d\n", x, y, color, fillType );
if (!PtVisible( dc->hSelf, x, y )) return FALSE;
EnterCriticalSection( &X11DRV_CritSection );
result = CALL_LARGE_STACK( X11DRV_DoFloodFill, &params );
LeaveCriticalSection( &X11DRV_CritSection );
return result;
if (GetRgnBox( dc->hGCClipRgn, &rect ) == ERROR) return FALSE;
if (!(image = TSXGetImage( display, physDev->drawable,
rect.left,
rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
AllPlanes, ZPixmap ))) return FALSE;
wine_tsx11_lock();
if (X11DRV_SetupGCForBrush( dc ))
{
/* Update the pixmap from the DIB section */
X11DRV_LockDIBSection(dc, DIB_Status_GdiMod, FALSE);
/* ROP mode is always GXcopy for flood-fill */
XSetFunction( display, physDev->gc, GXcopy );
X11DRV_InternalFloodFill(image, dc,
XLPTODP(dc,x) + dc->DCOrgX - rect.left,
YLPTODP(dc,y) + dc->DCOrgY - rect.top,
rect.left, rect.top,
X11DRV_PALETTE_ToPhysical( dc, color ),
fillType );
/* Update the DIBSection of the dc's bitmap */
X11DRV_UnlockDIBSection(dc, TRUE);
}
XDestroyImage( image );
wine_tsx11_unlock();
return TRUE;
}
/**********************************************************************

78
graphics/x11drv/oembitmap.c
View File

@ -19,8 +19,12 @@ typedef unsigned long Pixel;
#include <stdlib.h>
#include <string.h>
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/winuser16.h"
#include "bitmap.h"
#include "callback.h"
#include "color.h"
#include "cursoricon.h"
#include "debugtools.h"
@ -352,30 +356,6 @@ static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
}
#endif /* defined(HAVE_LIBXXPM) */
/***********************************************************************
* OBM_CreatePixmaps
*
* Create the 2 pixmaps from XPM data.
*
* The Xlib critical section must be entered before calling this function.
*/
#ifdef HAVE_LIBXXPM
typedef struct
{
char **data;
XpmAttributes *attrs;
Pixmap pixmap;
Pixmap pixmask;
} OBM_PIXMAP_DESCR;
static int OBM_CreatePixmaps( OBM_PIXMAP_DESCR *descr )
{
return XpmCreatePixmapFromData( display, X11DRV_GetXRootWindow(), descr->data,
&descr->pixmap, &descr->pixmask, descr->attrs );
}
#endif /* defined(HAVE_LIBXXPM) */
/***********************************************************************
* OBM_CreateBitmaps
@ -386,50 +366,44 @@ static BOOL OBM_CreateBitmaps( char **data, BOOL color,
HBITMAP16 *bitmap, HBITMAP16 *mask, POINT *hotspot )
{
#ifdef HAVE_LIBXXPM
OBM_PIXMAP_DESCR descr;
XpmAttributes *attrs;
Pixmap pixmap, pixmask;
int err;
descr.attrs = (XpmAttributes *)HeapAlloc( GetProcessHeap(), 0,
XpmAttributesSize() );
if (descr.attrs == NULL) return FALSE;
descr.attrs->valuemask = XpmColormap | XpmDepth | XpmColorSymbols | XpmHotspot;
descr.attrs->colormap = X11DRV_PALETTE_PaletteXColormap;
descr.attrs->depth = color ? X11DRV_GetDepth() : 1;
descr.attrs->colorsymbols = (descr.attrs->depth > 1) ? OBM_Colors : OBM_BlackAndWhite;
descr.attrs->numsymbols = (descr.attrs->depth > 1) ? NB_COLOR_SYMBOLS : 2;
descr.data = data;
EnterCriticalSection( &X11DRV_CritSection );
err = CALL_LARGE_STACK( OBM_CreatePixmaps, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
attrs = (XpmAttributes *)HeapAlloc( GetProcessHeap(), 0, XpmAttributesSize() );
if (attrs == NULL) return FALSE;
attrs->valuemask = XpmColormap | XpmDepth | XpmColorSymbols | XpmHotspot;
attrs->colormap = X11DRV_PALETTE_PaletteXColormap;
attrs->depth = color ? X11DRV_GetDepth() : 1;
attrs->colorsymbols = (attrs->depth > 1) ? OBM_Colors : OBM_BlackAndWhite;
attrs->numsymbols = (attrs->depth > 1) ? NB_COLOR_SYMBOLS : 2;
err = TSXpmCreatePixmapFromData( display, X11DRV_GetXRootWindow(), data,
&pixmap, &pixmask, attrs );
if (err != XpmSuccess)
{
HeapFree( GetProcessHeap(), 0, descr.attrs );
HeapFree( GetProcessHeap(), 0, attrs );
return FALSE;
}
if (hotspot)
{
hotspot->x = descr.attrs->x_hotspot;
hotspot->y = descr.attrs->y_hotspot;
hotspot->x = attrs->x_hotspot;
hotspot->y = attrs->y_hotspot;
}
if (bitmap)
*bitmap = OBM_MakeBitmap( descr.attrs->width, descr.attrs->height,
descr.attrs->depth, descr.pixmap );
*bitmap = OBM_MakeBitmap( attrs->width, attrs->height,
attrs->depth, pixmap );
if (mask)
*mask = OBM_MakeBitmap( descr.attrs->width, descr.attrs->height,
1, descr.pixmask );
*mask = OBM_MakeBitmap( attrs->width, attrs->height,
1, pixmask );
HeapFree( GetProcessHeap(), 0, descr.attrs );
HeapFree( GetProcessHeap(), 0, attrs );
if (descr.pixmap && (!bitmap || !*bitmap))
TSXFreePixmap( display, descr.pixmap );
if (descr.pixmask && (!mask || !*mask))
TSXFreePixmap( display, descr.pixmask );
if (pixmap && (!bitmap || !*bitmap)) TSXFreePixmap( display, pixmap );
if (pixmask && (!mask || !*mask)) TSXFreePixmap( display, pixmask );
if (bitmap && !*bitmap)
{

4
include/callback.h
View File

@ -13,10 +13,6 @@
#include "wine/winuser16.h"
extern void SYSDEPS_SwitchToThreadStack( void (*func)(void) ) WINE_NORETURN;
extern int SYSDEPS_CallOnLargeStack( int (*func)(void *), void *arg );
#define CALL_LARGE_STACK( func, arg ) \
SYSDEPS_CallOnLargeStack( (int (*)(void *))(func), (void *)(arg) )
typedef void (*RELAY)();
extern FARPROC THUNK_Alloc( FARPROC16 func, RELAY relay );

30
include/x11drv.h
View File

@ -240,36 +240,6 @@ typedef struct
} X11DRV_DIBSECTION;
/* This structure holds the arguments for DIB_SetImageBits() */
typedef struct
{
struct tagDC *dc;
LPCVOID bits;
XImage *image;
PALETTEENTRY *palentry;
int lines;
DWORD infoWidth;
WORD depth;
WORD infoBpp;
WORD compression;
RGBQUAD *colorMap;
int nColorMap;
Drawable drawable;
GC gc;
int xSrc;
int ySrc;
int xDest;
int yDest;
int width;
int height;
DWORD rMask;
DWORD gMask;
DWORD bMask;
BOOL useShm;
int dibpitch;
} X11DRV_DIB_IMAGEBITS_DESCR;
extern int *X11DRV_DIB_BuildColorMap( struct tagDC *dc, WORD coloruse,
WORD depth, const BITMAPINFO *info,
int *nColors );

28
scheduler/sysdeps.c
View File

@ -274,10 +274,6 @@ int SYSDEPS_CallOnStack( LPVOID stackTop, LPVOID stackLow,
/***********************************************************************
* SYSDEPS_SwitchToThreadStack
*/
static LPVOID SYSDEPS_LargeStackTop = NULL;
static LPVOID SYSDEPS_LargeStackLow = NULL;
void SYSDEPS_SwitchToThreadStack( void (*func)(void) )
{
DWORD page_size = getpagesize();
@ -298,34 +294,10 @@ void SYSDEPS_SwitchToThreadStack( void (*func)(void) )
teb->stack_top = (LPVOID) cur_stack;
teb->stack_low = (LPVOID)(cur_stack - rl.rlim_cur);
#if 0
SYSDEPS_LargeStackTop = (LPVOID)(cur_stack - 2*page_size);
SYSDEPS_LargeStackLow = (LPVOID)(cur_stack - rl.rlim_cur);
#endif
SYSDEPS_CallOnStack( stackTop, stackLow,
(int (*)(void *))func, NULL );
}
/***********************************************************************
* SYSDEPS_CallOnLargeStack
*/
int SYSDEPS_CallOnLargeStack( int (*func)(LPVOID), LPVOID arg )
{
static int recurse = 0;
int retv;
if ( recurse++ == 0 && SYSDEPS_LargeStackTop )
retv = SYSDEPS_CallOnStack( SYSDEPS_LargeStackTop,
SYSDEPS_LargeStackLow, func, arg );
else
retv = func( arg );
recurse--;
return retv;
}
/**********************************************************************
* NtCurrentTeb (NTDLL.89)
*

11
windows/x11drv/mouse.c
View File

@ -8,11 +8,12 @@
#include "ts_xlib.h"
#include "callback.h"
#include "windef.h"
#include "wine/winuser16.h"
#include "debugtools.h"
#include "mouse.h"
#include "win.h"
#include "windef.h"
#include "x11drv.h"
DEFAULT_DEBUG_CHANNEL(cursor);
@ -167,9 +168,9 @@ void X11DRV_SetCursor( CURSORICONINFO *lpCursor )
{
BOOL success;
EnterCriticalSection( &X11DRV_CritSection );
success = CALL_LARGE_STACK( X11DRV_MOUSE_DoSetCursor, lpCursor );
LeaveCriticalSection( &X11DRV_CritSection );
wine_tsx11_lock();
success = X11DRV_MOUSE_DoSetCursor( lpCursor );
wine_tsx11_unlock();
if ( !success ) return;
if (X11DRV_GetXRootWindow() != DefaultRootWindow(display))