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

Added pBitmapBits and pCreateBitmap to the GDI function table and 

moved the X11 dependent stuff out of objects/bitmap.c into x11drv.
This commit is contained in:
Huw D M Davies 1998-10-28 09:53:53 +00:00 committed by Alexandre Julliard
parent 309dbe10ef
commit 87f87bf61c
15 changed files with 757 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
graphics/metafiledrv/init.c
View File

@ -17,7 +17,9 @@ static const DC_FUNCTIONS MFDRV_Funcs =
{
MFDRV_Arc, /* pArc */
MFDRV_BitBlt, /* pBitBlt */
NULL, /* pBitmapBits */
MFDRV_Chord, /* pChord */
NULL, /* pCreateBitmap */
NULL, /* no implementation */ /* pCreateDC */
NULL, /* no implementation */ /* pDeleteDC */
NULL, /* pDeleteObject */

2
graphics/psdrv/init.c
View File

@ -22,7 +22,9 @@ static const DC_FUNCTIONS PSDRV_Funcs =
{
PSDRV_Arc, /* pArc */
NULL, /* pBitBlt */
NULL, /* pBitmapBits */
PSDRV_Chord, /* pChord */
NULL, /* pCreateBitmap */
PSDRV_CreateDC, /* pCreateDC */
PSDRV_DeleteDC, /* pDeleteDC */
NULL, /* pDeleteObject */

2
graphics/win16drv/init.c
View File

@ -51,7 +51,9 @@ static const DC_FUNCTIONS WIN16DRV_Funcs =
{
NULL, /* pArc */
NULL, /* pBitBlt */
NULL, /* pBitmapBits */
NULL, /* pChord */
NULL, /* pCreateBitmap */
WIN16DRV_CreateDC, /* pCreateDC */
NULL, /* pDeleteDC */
NULL, /* pDeleteObject */

455
graphics/x11drv/bitmap.c
View File

@ -1,5 +1,5 @@
/*
* GDI bitmap objects
* X11DRV bitmap objects
*
* Copyright 1993 Alexandre Julliard
*/
@ -14,6 +14,24 @@
#include "bitmap.h"
#include "heap.h"
#include "debug.h"
#include "xmalloc.h"
#include "x11drv.h"
#ifdef PRELIMINARY_WING16_SUPPORT
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#endif
/* GCs used for B&W and color bitmap operations */
GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
#define BITMAP_WIDTH_BYTES(width,bpp) \
(((bpp) == 24) ? (width) * 4 : ( ((bpp) == 15) ? (width) * 2 : \
((width) * (bpp) + 15) / 16 * 2 ))
/***********************************************************************
* X11DRV_BITMAP_Init
@ -51,9 +69,21 @@ HBITMAP32 X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP32 hbitmap,
{
HRGN32 hrgn;
HBITMAP32 prevHandle = dc->w.hBitmap;
X11DRV_PHYSBITMAP *pbitmap;
if (!(dc->w.flags & DC_MEMORY)) return 0;
if(!bmp->DDBitmap)
if(!X11DRV_CreateBitmap(hbitmap))
return 0;
if(bmp->DDBitmap->funcs != dc->funcs) {
WARN(bitmap, "Trying to select non-X11 DDB into an X11 dc\n");
return 0;
}
pbitmap = bmp->DDBitmap->physBitmap;
dc->w.totalExtent.left = 0;
dc->w.totalExtent.top = 0;
dc->w.totalExtent.right = bmp->bitmap.bmWidth;
@ -69,7 +99,7 @@ HBITMAP32 X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP32 hbitmap,
dc->w.hVisRgn = hrgn;
}
dc->u.x.drawable = bmp->pixmap;
dc->u.x.drawable = pbitmap->pixmap;
dc->w.hBitmap = hbitmap;
/* Change GC depth if needed */
@ -84,3 +114,422 @@ HBITMAP32 X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP32 hbitmap,
else CLIPPING_UpdateGCRegion( dc ); /* Just update GC clip region */
return prevHandle;
}
/***********************************************************************
* XPutImage_wrapper
*
* Wrapper to call XPutImage with CALL_LARGE_STACK.
*/
struct XPutImage_descr
{
BITMAPOBJ *bmp;
XImage *image;
INT32 width;
INT32 height;
};
static int XPutImage_wrapper( const struct XPutImage_descr *descr )
{
return XPutImage( display,
((X11DRV_PHYSBITMAP *)descr->bmp->DDBitmap->physBitmap)->pixmap,
BITMAP_GC(descr->bmp),
descr->image, 0, 0, 0, 0, descr->width, descr->height );
}
/***************************************************************************
*
* X11DRV_AllocBitmap
*
* Allocate DDBitmap and physBitmap
*
*/
X11DRV_PHYSBITMAP *X11DRV_AllocBitmap( BITMAPOBJ *bmp )
{
X11DRV_PHYSBITMAP *pbitmap;
if(!(bmp->DDBitmap = HeapAlloc(GetProcessHeap(), 0, sizeof(DDBITMAP)))) {
WARN(bitmap, "Can't alloc DDBITMAP\n");
return NULL;
}
if(!(pbitmap = HeapAlloc(GetProcessHeap(), 0,sizeof(X11DRV_PHYSBITMAP)))) {
WARN(bitmap, "Can't alloc X11DRV_PHYSBITMAP\n");
HeapFree(GetProcessHeap(), 0, bmp->DDBitmap);
return NULL;
}
bmp->DDBitmap->physBitmap = pbitmap;
bmp->DDBitmap->funcs = DRIVER_FindDriver( "DISPLAY" );
return pbitmap;
}
/****************************************************************************
*
* X11DRV_CreateBitmap
*
* Create a device dependent X11 bitmap
*
* Returns TRUE on success else FALSE
*
*/
BOOL32 X11DRV_CreateBitmap( HBITMAP32 hbitmap )
{
X11DRV_PHYSBITMAP *pbitmap;
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if(!bmp) {
WARN(bitmap, "Bad bitmap handle %08x\n", hbitmap);
return FALSE;
}
/* Check parameters */
if (bmp->bitmap.bmPlanes != 1) return 0;
if ((bmp->bitmap.bmBitsPixel != 1) &&
(bmp->bitmap.bmBitsPixel != screenDepth)) {
GDI_HEAP_UNLOCK( hbitmap );
return FALSE;
}
pbitmap = X11DRV_AllocBitmap( bmp );
if(!pbitmap) return FALSE;
/* Create the pixmap */
pbitmap->pixmap = TSXCreatePixmap(display, rootWindow, bmp->bitmap.bmWidth,
bmp->bitmap.bmHeight, bmp->bitmap.bmBitsPixel);
if (!pbitmap->pixmap) {
WARN(bitmap, "Can't create Pixmap\n");
HeapFree(GetProcessHeap(), 0, bmp->DDBitmap->physBitmap);
HeapFree(GetProcessHeap(), 0, bmp->DDBitmap);
GDI_HEAP_UNLOCK( hbitmap );
return FALSE;
}
if (bmp->bitmap.bmBits) /* Set bitmap bits */
X11DRV_BitmapBits( hbitmap, bmp->bitmap.bmBits,
bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes,
DDB_SET );
GDI_HEAP_UNLOCK( hbitmap );
return TRUE;
}
/***********************************************************************
* 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,
((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap,
0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
AllPlanes, ZPixmap );
}
/***********************************************************************
* X11DRV_GetBitmapBits
*
* RETURNS
* Success: Number of bytes copied
* Failure: 0
*/
static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
{
LONG old_height, height;
XImage *image;
LPBYTE tbuf;
int h, w, pad;
pad = BITMAP_GetBitsPadding(bmp->bitmap.bmWidth, bmp->bitmap.bmBitsPixel);
if (pad == -1)
return 0;
EnterCriticalSection( &X11DRV_CritSection );
/* Hack: change the bitmap height temporarily to avoid */
/* getting unnecessary bitmap rows. */
old_height = bmp->bitmap.bmHeight;
height = bmp->bitmap.bmHeight = count / bmp->bitmap.bmWidthBytes;
image = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
bmp->bitmap.bmHeight = old_height;
/* copy XImage to 16 bit padded image buffer with real bitsperpixel */
tbuf = buffer;
switch (bmp->bitmap.bmBitsPixel)
{
case 1:
for (h=0;h<height;h++)
{
*tbuf = 0;
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
if ((w%8) == 0)
*tbuf = 0;
*tbuf |= XGetPixel(image,w,h)<<(7-(w&7));
if ((w&7) == 7) ++tbuf;
}
tbuf += pad;
}
break;
case 4:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
if (!(w & 1)) *tbuf = XGetPixel( image, w, h) << 4;
else *tbuf++ |= XGetPixel( image, w, h) & 0x0f;
}
tbuf += pad;
}
break;
case 8:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
*tbuf++ = XGetPixel(image,w,h);
tbuf += pad;
}
break;
case 15:
case 16:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
long pixel = XGetPixel(image,w,h);
*tbuf++ = pixel & 0xff;
*tbuf++ = (pixel>>8) & 0xff;
}
}
break;
case 24:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
long pixel = XGetPixel(image,w,h);
*tbuf++ = pixel & 0xff;
*tbuf++ = (pixel>> 8) & 0xff;
*tbuf++ = (pixel>>16) & 0xff;
}
tbuf += pad;
}
break;
case 32:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
long pixel = XGetPixel(image,w,h);
*tbuf++ = pixel & 0xff;
*tbuf++ = (pixel>> 8) & 0xff;
*tbuf++ = (pixel>>16) & 0xff;
*tbuf++ = (pixel>>24) & 0xff;
}
tbuf += pad;
}
break;
default:
FIXME(bitmap, "Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
}
XDestroyImage( image );
LeaveCriticalSection( &X11DRV_CritSection );
return count;
}
/******************************************************************************
* X11DRV_SetBitmapBits
*
* RETURNS
* Success: Number of bytes used in setting the bitmap bits
* Failure: 0
*/
static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
{
struct XPutImage_descr descr;
LONG height;
XImage *image;
LPBYTE sbuf, tmpbuffer;
int w, h, pad, widthbytes;
pad = BITMAP_GetBitsPadding(bmp->bitmap.bmWidth, bmp->bitmap.bmBitsPixel);
if (pad == -1)
return 0;
sbuf = (LPBYTE)bits;
widthbytes = (((bmp->bitmap.bmWidth * bmp->bitmap.bmBitsPixel) + 31) /
32) * 4;
height = bmp->bitmap.bmHeight;
tmpbuffer = (LPBYTE)xmalloc(widthbytes*height);
EnterCriticalSection( &X11DRV_CritSection );
image = XCreateImage( display, DefaultVisualOfScreen(screen),
bmp->bitmap.bmBitsPixel, ZPixmap, 0, tmpbuffer,
bmp->bitmap.bmWidth,height,32,widthbytes );
/* copy 16 bit padded image buffer with real bitsperpixel to XImage */
sbuf = (LPBYTE)bits;
switch (bmp->bitmap.bmBitsPixel)
{
case 1:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,(sbuf[0]>>(7-(w&7))) & 1);
if ((w&7) == 7)
sbuf++;
}
sbuf += pad;
}
break;
case 4:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
if (!(w & 1)) XPutPixel( image, w, h, *sbuf >> 4 );
else XPutPixel( image, w, h, *sbuf++ & 0xf );
}
sbuf += pad;
}
break;
case 8:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
XPutPixel(image,w,h,*sbuf++);
sbuf += pad;
}
break;
case 15:
case 16:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,sbuf[1]*256+sbuf[0]);
sbuf+=2;
}
}
break;
case 24:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
sbuf += 3;
}
sbuf += pad;
}
break;
case 32:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,(sbuf[3]<<24)+(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
sbuf += 4;
}
sbuf += pad;
}
break;
default:
FIXME(bitmap, "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 );
XDestroyImage( image ); /* frees tmpbuffer too */
LeaveCriticalSection( &X11DRV_CritSection );
return count;
}
/***********************************************************************
* X11DRV_BitmapBits
*/
LONG X11DRV_BitmapBits(HBITMAP32 hbitmap, void *bits, LONG count, WORD flags)
{
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
LONG ret;
if(!bmp) {
WARN(bitmap, "Bad bitmap handle %08x\n", hbitmap);
return FALSE;
}
if(flags == DDB_GET)
ret = X11DRV_GetBitmapBits(bmp, bits, count);
else if(flags == DDB_SET)
ret = X11DRV_SetBitmapBits(bmp, bits, count);
else {
ERR(bitmap, "Unknown flags value %d\n", flags);
ret = 0;
}
GDI_HEAP_UNLOCK( hbitmap );
return ret;
}
/***********************************************************************
* X11DRV_BITMAP_DeleteObject
*/
BOOL32 X11DRV_BITMAP_DeleteObject( HBITMAP32 hbitmap, BITMAPOBJ * bmp )
{
X11DRV_PHYSBITMAP *pbitmap = bmp->DDBitmap->physBitmap;
#ifdef PRELIMINARY_WING16_SUPPORT
if( bmp->bitmap.bmBits )
TSXShmDetach( display, (XShmSegmentInfo*)bmp->bitmap.bmBits );
#endif
TSXFreePixmap( display, pbitmap->pixmap );
#ifdef PRELIMINARY_WING16_SUPPORT
if( bmp->bitmap.bmBits )
{
__ShmBitmapCtl* p = (__ShmBitmapCtl*)bmp->bitmap.bmBits;
WORD sel = HIWORD(p->bits);
unsigned long l, limit = GetSelectorLimit(sel);
for( l = 0; l < limit; l += 0x10000, sel += __AHINCR )
FreeSelector(sel);
shmctl(p->si.shmid, IPC_RMID, NULL);
shmdt(p->si.shmaddr); /* already marked for destruction */
}
#endif
HeapFree( GetProcessHeap(), 0, bmp->DDBitmap->physBitmap );
HeapFree( GetProcessHeap(), 0, bmp->DDBitmap );
bmp->DDBitmap = NULL;
return TRUE;
}

16
graphics/x11drv/brush.c
View File

@ -163,22 +163,34 @@ static void BRUSH_SelectSolidBrush( DC *dc, COLORREF color )
*/
static BOOL32 BRUSH_SelectPatternBrush( DC * dc, HBITMAP32 hbitmap )
{
X11DRV_PHYSBITMAP *pbitmap;
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
if(!bmp->DDBitmap)
if(!X11DRV_CreateBitmap(hbitmap))
return 0;
if(bmp->DDBitmap->funcs != dc->funcs) {
WARN(bitmap, "Trying to select non-X11 DDB into an X11 dc\n");
return 0;
}
pbitmap = bmp->DDBitmap->physBitmap;
if ((dc->w.bitsPerPixel == 1) && (bmp->bitmap.bmBitsPixel != 1))
{
/* Special case: a color pattern on a monochrome DC */
dc->u.x.brush.pixmap = TSXCreatePixmap( display, rootWindow, 8, 8, 1 );
/* FIXME: should probably convert to monochrome instead */
TSXCopyPlane( display, bmp->pixmap, dc->u.x.brush.pixmap,
TSXCopyPlane( display, pbitmap->pixmap, dc->u.x.brush.pixmap,
BITMAP_monoGC, 0, 0, 8, 8, 0, 0, 1 );
}
else
{
dc->u.x.brush.pixmap = TSXCreatePixmap( display, rootWindow,
8, 8, bmp->bitmap.bmBitsPixel );
TSXCopyArea( display, bmp->pixmap, dc->u.x.brush.pixmap,
TSXCopyArea( display, pbitmap->pixmap, dc->u.x.brush.pixmap,
BITMAP_GC(bmp), 0, 0, 8, 8, 0, 0 );
}

11
graphics/x11drv/init.c
View File

@ -21,10 +21,12 @@ static const DC_FUNCTIONS X11DRV_Funcs =
{
X11DRV_Arc, /* pArc */
X11DRV_BitBlt, /* pBitBlt */
X11DRV_BitmapBits, /* pBitmapBits */
X11DRV_Chord, /* pChord */
X11DRV_CreateBitmap, /* pCreateBitmap */
X11DRV_CreateDC, /* pCreateDC */
X11DRV_DeleteDC, /* pDeleteDC */
NULL, /* pDeleteObject */
X11DRV_DeleteObject, /* pDeleteObject */
X11DRV_Ellipse, /* pEllipse */
X11DRV_EnumDeviceFonts, /* pEnumDeviceFonts */
X11DRV_Escape, /* pEscape */
@ -173,10 +175,13 @@ static BOOL32 X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
dc->w.devCaps = &X11DRV_DevCaps;
if (dc->w.flags & DC_MEMORY)
{
X11DRV_PHYSBITMAP *pbitmap;
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( dc->w.hBitmap,
BITMAP_MAGIC );
physDev->drawable = bmp->pixmap;
physDev->gc = TSXCreateGC( display, physDev->drawable, 0, NULL );
X11DRV_CreateBitmap( dc->w.hBitmap );
pbitmap = bmp->DDBitmap->physBitmap;
physDev->drawable = pbitmap->pixmap;
physDev->gc = TSXCreateGC(display, physDev->drawable, 0, NULL);
dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
dc->w.totalExtent.left = 0;

26
graphics/x11drv/objects.c
View File

@ -21,6 +21,7 @@ extern HFONT32 X11DRV_FONT_SelectObject( DC * dc, HFONT32 hfont,
FONTOBJ * font );
extern HPEN32 X11DRV_PEN_SelectObject( DC * dc, HPEN32 hpen, PENOBJ * pen );
extern BOOL32 X11DRV_BITMAP_DeleteObject( HBITMAP32 hbitmap, BITMAPOBJ *bmp );
/***********************************************************************
* X11DRV_SelectObject
@ -54,3 +55,28 @@ HGDIOBJ32 X11DRV_SelectObject( DC *dc, HGDIOBJ32 handle )
GDI_HEAP_UNLOCK( handle );
return ret;
}
/***********************************************************************
* X11DRV_DeleteObject
*/
BOOL32 X11DRV_DeleteObject( HGDIOBJ32 handle )
{
GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
BOOL32 ret = 0;
if (!ptr) return FALSE;
switch(ptr->wMagic) {
case BITMAP_MAGIC:
ret = X11DRV_BITMAP_DeleteObject( handle, (BITMAPOBJ *)ptr );
break;
default:
ERR(gdi, "Shouldn't be here!\n");
ret = FALSE;
break;
}
GDI_HEAP_UNLOCK( handle );
return ret;
}

54
include/bitmap.h
View File

@ -8,19 +8,6 @@
#define __WINE_BITMAP_H
#include "gdi.h"
#include "xmalloc.h"
#ifdef PRELIMINARY_WING16_SUPPORT
/* FIXME: this doesn't belong here */
#include "ts_xshm.h"
typedef struct
{
XShmSegmentInfo si;
SEGPTR bits;
} __ShmBitmapCtl;
#endif
/* Additional info for DIB section objects */
typedef struct
@ -40,52 +27,51 @@ typedef struct
} DIBSECTIONOBJ;
/* Flags used for BitmapBits. We only use the first two at the moment */
#define DDB_SET 1
#define DDB_GET 2
#define DDB_COPY 4
#define DDB_SETWITHFILLER 8
typedef struct {
const struct tagDC_FUNCS *funcs; /* DC function table */
void *physBitmap; /* ptr to device specific data */
} DDBITMAP;
/* GDI logical bitmap object */
typedef struct
typedef struct tagBITMAPOBJ
{
GDIOBJHDR header;
BITMAP16 bitmap;
Pixmap pixmap;
SIZE16 size; /* For SetBitmapDimension() */
BITMAP32 bitmap;
SIZE32 size; /* For SetBitmapDimension() */
DDBITMAP *DDBitmap;
/* For device-independent bitmaps: */
DIBSECTIONOBJ *dib;
} BITMAPOBJ;
/* GCs used for B&W and color bitmap operations */
extern GC BITMAP_monoGC, BITMAP_colorGC;
#define BITMAP_GC(bmp) \
(((bmp)->bitmap.bmBitsPixel == 1) ? BITMAP_monoGC : BITMAP_colorGC)
#define BITMAP_WIDTH_BYTES(width,bpp) \
(((bpp) == 24) ? (width) * 4 : ( ((bpp) == 15) ? (width) * 2 : \
((width) * (bpp) + 15) / 16 * 2 ))
#define XCREATEIMAGE(image,width,height,bpp) \
{ \
int width_bytes = DIB_GetXImageWidthBytes( (width), (bpp) ); \
(image) = TSXCreateImage(display, DefaultVisualOfScreen(screen), \
(bpp), ZPixmap, 0, xcalloc( (height)*width_bytes ),\
(width), (height), 32, width_bytes ); \
}
/* objects/bitmap.c */
extern BOOL32 BITMAP_Init(void);
extern INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer );
extern INT32 BITMAP_GetObject32( BITMAPOBJ * bmp, INT32 count, LPVOID buffer );
extern BOOL32 BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bitmap );
extern XImage *BITMAP_GetXImage( const BITMAPOBJ *bmp );
extern INT32 BITMAP_GetBitsPadding( int width, int depth );
extern INT32 BITMAP_GetBitsWidth( int width, int depth );
extern HBITMAP32 BITMAP_LoadBitmap32W(HINSTANCE32 instance,LPCWSTR name,
UINT32 loadflags);
extern HBITMAP32 BITMAP_CopyBitmap( HBITMAP32 hbitmap );
/* objects/dib.c */
extern int DIB_GetDIBWidthBytes( int width, int depth );
extern int DIB_GetXImageWidthBytes( int width, int depth );
extern int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse );
extern int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
int *height, WORD *bpp, WORD *compr );
extern void DIB_UpdateDIBSection( DC *dc, BOOL32 toDIB );
extern void DIB_DeleteDIBSection( BITMAPOBJ *bmp );
extern void DIB_SelectDIBSection( DC *dc, BITMAPOBJ *bmp );

4
include/gdi.h
View File

@ -173,10 +173,12 @@ typedef struct tagDC_FUNCS
{
BOOL32 (*pArc)(DC*,INT32,INT32,INT32,INT32,INT32,INT32,INT32,INT32);
BOOL32 (*pBitBlt)(DC*,INT32,INT32,INT32,INT32,DC*,INT32,INT32,DWORD);
LONG (*pBitmapBits)(HBITMAP32,void*,LONG,WORD);
BOOL32 (*pChord)(DC*,INT32,INT32,INT32,INT32,INT32,INT32,INT32,INT32);
BOOL32 (*pCreateBitmap)(HBITMAP32);
BOOL32 (*pCreateDC)(DC*,LPCSTR,LPCSTR,LPCSTR,const DEVMODE16*);
BOOL32 (*pDeleteDC)(DC*);
BOOL32 (*pDeleteObject)(HGDIOBJ16);
BOOL32 (*pDeleteObject)(HGDIOBJ32);
BOOL32 (*pEllipse)(DC*,INT32,INT32,INT32,INT32);
BOOL32 (*pEnumDeviceFonts)(DC*,LPLOGFONT16,DEVICEFONTENUMPROC,LPARAM);
INT32 (*pEscape)(DC*,INT32,INT32,SEGPTR,SEGPTR);

43
include/x11drv.h
View File

@ -9,6 +9,7 @@
#include "ts_xutil.h"
#include "winbase.h"
#include "windows.h"
#include "xmalloc.h" /* for XCREATEIMAGE macro */
/* X physical pen */
typedef struct
@ -47,6 +48,17 @@ typedef struct
int textPixel;
} X11DRV_PDEVICE;
typedef struct {
Pixmap pixmap;
} X11DRV_PHYSBITMAP;
/* GCs used for B&W and color bitmap operations */
extern GC BITMAP_monoGC, BITMAP_colorGC;
#define BITMAP_GC(bmp) \
(((bmp)->bitmap.bmBitsPixel == 1) ? BITMAP_monoGC : BITMAP_colorGC)
typedef INT32 (*DEVICEFONTENUMPROC)(LPENUMLOGFONT16,LPNEWTEXTMETRIC16,UINT16,LPARAM);
/* Wine driver X11 functions */
@ -111,18 +123,45 @@ extern BOOL32 X11DRV_ExtFloodFill( struct tagDC *dc, INT32 x, INT32 y,
extern BOOL32 X11DRV_ExtTextOut( struct tagDC *dc, INT32 x, INT32 y,
UINT32 flags, const RECT32 *lprect,
LPCSTR str, UINT32 count, const INT32 *lpDx );
extern BOOL32 X11DRV_CreateBitmap( HBITMAP32 hbitmap );
extern BOOL32 X11DRV_DeleteObject( HGDIOBJ32 handle );
extern LONG X11DRV_BitmapBits( HBITMAP32 hbitmap, void *bits, LONG count,
WORD flags );
extern INT32 X11DRV_SetDIBitsToDevice( struct tagDC *dc, INT32 xDest,
INT32 yDest, DWORD cx, DWORD cy,
INT32 xSrc, INT32 ySrc,
UINT32 startscan, UINT32 lines,
LPCVOID bits, const BITMAPINFO *info,
UINT32 coloruse );
extern INT32 X11DRV_DeviceBitmapBits( struct tagDC *dc, HBITMAP32 hbitmap,
WORD fGet, UINT32 startscan,
UINT32 lines, LPSTR bits,
LPBITMAPINFO info, UINT32 coloruse );
/* X11 driver internal functions */
extern BOOL32 X11DRV_BITMAP_Init(void);
extern BOOL32 X11DRV_BRUSH_Init(void);
extern BOOL32 X11DRV_FONT_Init( struct tagDeviceCaps* );
struct tagBITMAPOBJ;
extern XImage *X11DRV_BITMAP_GetXImage( const struct tagBITMAPOBJ *bmp );
extern int X11DRV_DIB_GetXImageWidthBytes( int width, int depth );
extern BOOL32 X11DRV_DIB_Init(void);
extern X11DRV_PHYSBITMAP *X11DRV_AllocBitmap( struct tagBITMAPOBJ *bmp );
/* Xlib critical section */
extern CRITICAL_SECTION X11DRV_CritSection;
extern void _XInitImageFuncPtrs(XImage *);
#define XCREATEIMAGE(image,width,height,bpp) \
{ \
int width_bytes = X11DRV_DIB_GetXImageWidthBytes( (width), (bpp) ); \
(image) = TSXCreateImage(display, DefaultVisualOfScreen(screen), \
(bpp), ZPixmap, 0, xcalloc( (height)*width_bytes ),\
(width), (height), 32, width_bytes ); \
}
#endif /* __WINE_X11DRV_H */

488
objects/bitmap.c
View File

@ -2,51 +2,21 @@
* GDI bitmap objects
*
* Copyright 1993 Alexandre Julliard
* 1998 Huw D M Davies
*/
#include <stdlib.h>
#include <string.h>
#include "ts_xlib.h"
#include "ts_xutil.h"
#include "gdi.h"
#include "callback.h"
#include "dc.h"
#include "bitmap.h"
#include "heap.h"
#include "global.h"
#include "debug.h"
#include "sysmetrics.h"
#include "cursoricon.h"
#include "color.h"
#include "debug.h"
#ifdef PRELIMINARY_WING16_SUPPORT
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#endif
/* GCs used for B&W and color bitmap operations */
GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
/***********************************************************************
* XPutImage_wrapper
*
* Wrapper to call XPutImage with CALL_LARGE_STACK.
*/
struct XPutImage_descr
{
BITMAPOBJ *bmp;
XImage *image;
INT32 width;
INT32 height;
};
static int XPutImage_wrapper( const struct XPutImage_descr *descr )
{
return XPutImage( display, descr->bmp->pixmap, BITMAP_GC(descr->bmp),
descr->image, 0, 0, 0, 0, descr->width, descr->height );
}
/***********************************************************************
* BITMAP_GetBitsPadding
@ -142,7 +112,6 @@ HBITMAP16 WINAPI CreateUserDiscardableBitmap16( WORD dummy,
}
/***********************************************************************
* CreateBitmap16 (GDI.48)
*/
@ -165,51 +134,51 @@ HBITMAP16 WINAPI CreateBitmap16( INT16 width, INT16 height, UINT16 planes,
*
* RETURNS
* Success: Handle to bitmap
* Failure: NULL
* Failure: 0
*/
HBITMAP32 WINAPI CreateBitmap32( INT32 width, INT32 height, UINT32 planes,
UINT32 bpp, LPCVOID bits )
{
BITMAPOBJ * bmpObjPtr;
BITMAPOBJ *bmp;
HBITMAP32 hbitmap;
planes = (BYTE)planes;
bpp = (BYTE)bpp;
TRACE(gdi, "%dx%d, %d colors\n", width, height, 1 << (planes*bpp) );
/* Check parameters */
if (!height || !width || planes != 1) return 0;
if ((bpp != 1) && (bpp != screenDepth)) return 0;
if (!height || !width) return 0;
if (planes != 1) {
FIXME(bitmap, "planes = %d\n", planes);
return 0;
}
if (height < 0) height = -height;
if (width < 0) width = -width;
/* Create the BITMAPOBJ */
hbitmap = GDI_AllocObject( sizeof(BITMAPOBJ), BITMAP_MAGIC );
if (!hbitmap) return 0;
bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
bmpObjPtr->size.cx = 0;
bmpObjPtr->size.cy = 0;
bmpObjPtr->bitmap.bmType = 0;
bmpObjPtr->bitmap.bmWidth = (INT16)width;
bmpObjPtr->bitmap.bmHeight = (INT16)height;
bmpObjPtr->bitmap.bmPlanes = (BYTE)planes;
bmpObjPtr->bitmap.bmBitsPixel = (BYTE)bpp;
bmpObjPtr->bitmap.bmWidthBytes = (INT16)BITMAP_WIDTH_BYTES( width, bpp );
bmpObjPtr->bitmap.bmBits = 0;
TRACE(bitmap, "%dx%d, %d colors returning %08x\n", width, height,
1 << (planes*bpp), hbitmap);
bmpObjPtr->dib = NULL;
bmp = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
/* Create the pixmap */
bmpObjPtr->pixmap = TSXCreatePixmap(display, rootWindow, width, height, bpp);
if (!bmpObjPtr->pixmap)
{
GDI_HEAP_FREE( hbitmap );
hbitmap = 0;
}
else if (bits) /* Set bitmap bits */
SetBitmapBits32( hbitmap, height * bmpObjPtr->bitmap.bmWidthBytes,
bmp->size.cx = 0;
bmp->size.cy = 0;
bmp->bitmap.bmType = 0;
bmp->bitmap.bmWidth = (INT16)width;
bmp->bitmap.bmHeight = (INT16)height;
bmp->bitmap.bmPlanes = (BYTE)planes;
bmp->bitmap.bmBitsPixel = (BYTE)bpp;
bmp->bitmap.bmWidthBytes = (INT16)BITMAP_WIDTH_BYTES( width, bpp );
bmp->bitmap.bmBits = NULL;
bmp->DDBitmap = NULL;
bmp->dib = NULL;
if (bits) /* Set bitmap bits */
SetBitmapBits32( hbitmap, height * bmp->bitmap.bmWidthBytes,
bits );
GDI_HEAP_UNLOCK( hbitmap );
return hbitmap;
@ -235,23 +204,26 @@ HBITMAP16 WINAPI CreateCompatibleBitmap16(HDC16 hdc, INT16 width, INT16 height)
*
* RETURNS
* Success: Handle to bitmap
* Failure: NULL
* Failure: 0
*/
HBITMAP32 WINAPI CreateCompatibleBitmap32( HDC32 hdc, INT32 width, INT32 height)
{
HBITMAP32 hbmpRet = 0;
DC *dc;
TRACE(gdi, "(%04x,%d,%d) = \n", hdc, width, height );
TRACE(bitmap, "(%04x,%d,%d) = \n", hdc, width, height );
if (!(dc = DC_GetDCPtr( hdc ))) return 0;
if ((width >0x1000) || (height > 0x1000))
{
FIXME(gdi,"got bad width %d or height %d, please look for reason\n",
width, height );
if ((width >0x1000) || (height > 0x1000)) {
FIXME(bitmap,"got bad width %d or height %d, please look for reason\n",
width, height );
return 0;
}
}
hbmpRet = CreateBitmap32( width, height, 1, dc->w.bitsPerPixel, NULL );
TRACE(gdi,"\t\t%04x\n", hbmpRet);
if(dc->funcs->pCreateBitmap)
dc->funcs->pCreateBitmap( hbmpRet );
TRACE(bitmap,"\t\t%04x\n", hbmpRet);
return hbmpRet;
}
@ -281,18 +253,6 @@ HBITMAP32 WINAPI CreateBitmapIndirect32(
}
/***********************************************************************
* BITMAP_GetXImage
*
* Get an X image for a bitmap. For use with CALL_LARGE_STACK.
*/
XImage *BITMAP_GetXImage( const BITMAPOBJ *bmp )
{
return XGetImage( display, bmp->pixmap, 0, 0, bmp->bitmap.bmWidth,
bmp->bitmap.bmHeight, AllPlanes, ZPixmap );
}
/***********************************************************************
* GetBitmapBits16 (GDI.74)
*/
@ -312,136 +272,52 @@ LONG WINAPI GetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPVOID buffer )
LONG WINAPI GetBitmapBits32(
HBITMAP32 hbitmap, /* [in] Handle to bitmap */
LONG count, /* [in] Number of bytes to copy */
LPVOID buffer) /* [out] Pointer to buffer to receive bits */
LPVOID bits) /* [out] Pointer to buffer to receive bits */
{
BITMAPOBJ * bmp;
LONG height, old_height;
XImage * image;
LPBYTE tbuf;
int h,w,pad;
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
LONG height, ret;
/* KLUDGE! */
if (!bmp) return 0;
if (count < 0) {
WARN(bitmap, "(%ld): Negative number of bytes passed???\n", count );
count = -count;
}
bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return 0;
/* Only get entire lines */
/* Only get entire lines */
height = count / bmp->bitmap.bmWidthBytes;
if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
count = height * bmp->bitmap.bmWidthBytes;
TRACE(bitmap, "%dx%d %d colors %p fetched height: %ld\n",
bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, buffer, height );
TRACE(bitmap, "(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, height );
pad = BITMAP_GetBitsPadding( bmp->bitmap.bmWidth, bmp->bitmap.bmBitsPixel );
if(bmp->DDBitmap) {
if (!height || (pad == -1))
{
GDI_HEAP_UNLOCK( hbitmap );
return 0;
}
TRACE(bitmap, "Calling device specific BitmapBits\n");
if(bmp->DDBitmap->funcs->pBitmapBits)
ret = bmp->DDBitmap->funcs->pBitmapBits(hbitmap, bits, count,
DDB_GET);
else {
ERR(bitmap, "BitmapBits == NULL??\n");
ret = 0;
}
EnterCriticalSection( &X11DRV_CritSection );
} else {
/* Hack: change the bitmap height temporarily to avoid */
/* getting unnecessary bitmap rows. */
old_height = bmp->bitmap.bmHeight;
bmp->bitmap.bmHeight = height;
image = (XImage *)CALL_LARGE_STACK( BITMAP_GetXImage, bmp );
bmp->bitmap.bmHeight = old_height;
/* copy XImage to 16 bit padded image buffer with real bitsperpixel */
tbuf = buffer;
switch (bmp->bitmap.bmBitsPixel)
{
case 1:
for (h=0;h<height;h++)
{
*tbuf = 0;
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
if ((w%8) == 0)
*tbuf = 0;
*tbuf |= XGetPixel(image,w,h)<<(7-(w&7));
if ((w&7) == 7) ++tbuf;
}
tbuf += pad;
}
break;
case 4:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
if (!(w & 1)) *tbuf = XGetPixel( image, w, h) << 4;
else *tbuf++ |= XGetPixel( image, w, h) & 0x0f;
}
tbuf += pad;
}
break;
case 8:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
*tbuf++ = XGetPixel(image,w,h);
tbuf += pad;
}
break;
case 15:
case 16:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
long pixel = XGetPixel(image,w,h);
*tbuf++ = pixel & 0xff;
*tbuf++ = (pixel>>8) & 0xff;
}
}
break;
case 24:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
long pixel = XGetPixel(image,w,h);
*tbuf++ = pixel & 0xff;
*tbuf++ = (pixel>> 8) & 0xff;
*tbuf++ = (pixel>>16) & 0xff;
}
tbuf += pad;
if(!bmp->bitmap.bmBits) {
WARN(bitmap, "Bitmap is empty\n");
ret = 0;
} else {
memcpy(bits, bmp->bitmap.bmBits, count);
ret = count;
}
break;
case 32:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
long pixel = XGetPixel(image,w,h);
*tbuf++ = pixel & 0xff;
*tbuf++ = (pixel>> 8) & 0xff;
*tbuf++ = (pixel>>16) & 0xff;
*tbuf++ = (pixel>>24) & 0xff;
}
tbuf += pad;
}
break;
default:
FIXME(bitmap, "Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
}
XDestroyImage( image );
LeaveCriticalSection( &X11DRV_CritSection );
GDI_HEAP_UNLOCK( hbitmap );
return height * bmp->bitmap.bmWidthBytes;
return ret;
}
@ -464,132 +340,53 @@ LONG WINAPI SetBitmapBits16( HBITMAP16 hbitmap, LONG count, LPCVOID buffer )
LONG WINAPI SetBitmapBits32(
HBITMAP32 hbitmap, /* [in] Handle to bitmap */
LONG count, /* [in] Number of bytes in bitmap array */
LPCVOID buffer) /* [in] Address of array with bitmap bits */
LPCVOID bits) /* [in] Address of array with bitmap bits */
{
struct XPutImage_descr descr;
BITMAPOBJ * bmp;
LONG height;
XImage * image;
LPBYTE sbuf,tmpbuffer;
int w,h,pad,widthbytes;
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
LONG height, ret;
/* KLUDGE! */
if (!bmp) return 0;
if (count < 0) {
WARN(bitmap, "(%ld): Negative number of bytes passed???\n", count );
count = -count;
}
bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return 0;
TRACE(bitmap, "%dx%d %d colors %p\n",
bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, buffer );
/* Only set entire lines */
/* Only get entire lines */
height = count / bmp->bitmap.bmWidthBytes;
if (height > bmp->bitmap.bmHeight) height = bmp->bitmap.bmHeight;
count = height * bmp->bitmap.bmWidthBytes;
pad = BITMAP_GetBitsPadding( bmp->bitmap.bmWidth, bmp->bitmap.bmBitsPixel );
TRACE(bitmap, "(%08x, %ld, %p) %dx%d %d colors fetched height: %ld\n",
hbitmap, count, bits, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
1 << bmp->bitmap.bmBitsPixel, height );
if (!height || (pad == -1))
{
GDI_HEAP_UNLOCK( hbitmap );
return 0;
}
if(bmp->DDBitmap) {
TRACE(bitmap, "Calling device specific BitmapBits\n");
if(bmp->DDBitmap->funcs->pBitmapBits)
ret = bmp->DDBitmap->funcs->pBitmapBits(hbitmap, (void *) bits,
count, DDB_SET);
else {
ERR(bitmap, "BitmapBits == NULL??\n");
ret = 0;
}
sbuf = (LPBYTE)buffer;
widthbytes = DIB_GetXImageWidthBytes(bmp->bitmap.bmWidth,bmp->bitmap.bmBitsPixel);
tmpbuffer = (LPBYTE)xmalloc(widthbytes*height);
EnterCriticalSection( &X11DRV_CritSection );
image = XCreateImage( display, DefaultVisualOfScreen(screen),
bmp->bitmap.bmBitsPixel, ZPixmap, 0, tmpbuffer,
bmp->bitmap.bmWidth,height,32,widthbytes );
/* copy 16 bit padded image buffer with real bitsperpixel to XImage */
sbuf = (LPBYTE)buffer;
switch (bmp->bitmap.bmBitsPixel)
{
case 1:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,(sbuf[0]>>(7-(w&7))) & 1);
if ((w&7) == 7)
sbuf++;
}
sbuf += pad;
}
break;
case 4:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
if (!(w & 1)) XPutPixel( image, w, h, *sbuf >> 4 );
else XPutPixel( image, w, h, *sbuf++ & 0xf );
}
sbuf += pad;
}
break;
case 8:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
XPutPixel(image,w,h,*sbuf++);
sbuf += pad;
}
break;
case 15:
case 16:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,sbuf[1]*256+sbuf[0]);
sbuf+=2;
}
}
break;
case 24:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
sbuf += 3;
}
sbuf += pad;
}
break;
case 32:
for (h=0;h<height;h++)
{
for (w=0;w<bmp->bitmap.bmWidth;w++)
{
XPutPixel(image,w,h,(sbuf[3]<<24)+(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
sbuf += 4;
}
sbuf += pad;
}
break;
default:
FIXME(bitmap, "Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
} else {
if(!bmp->bitmap.bmBits) /* Alloc enough for entire bitmap */
bmp->bitmap.bmBits = HeapAlloc( GetProcessHeap(), 0, count );
if(!bmp->bitmap.bmBits) {
WARN(bitmap, "Unable to allocate bit buffer\n");
ret = 0;
} else {
memcpy(bmp->bitmap.bmBits, bits, count);
ret = count;
}
}
descr.bmp = bmp;
descr.image = image;
descr.width = bmp->bitmap.bmWidth;
descr.height = height;
CALL_LARGE_STACK( XPutImage_wrapper, &descr );
XDestroyImage( image ); /* frees tmpbuffer too */
LeaveCriticalSection( &X11DRV_CritSection );
GDI_HEAP_UNLOCK( hbitmap );
return height * bmp->bitmap.bmWidthBytes;
return ret;
}
/***********************************************************************
@ -691,22 +488,30 @@ HANDLE32 WINAPI LoadImage32W( HINSTANCE32 hinst, LPCWSTR name, UINT32 type,
/**********************************************************************
* CopyBitmap32 (not an API)
*
* NOTES
* If it is not an API, why is it declared with WINAPI?
* BITMAP_CopyBitmap
*
*/
HBITMAP32 WINAPI CopyBitmap32 (HBITMAP32 hnd)
HBITMAP32 BITMAP_CopyBitmap(HBITMAP32 hbitmap)
{
BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
HBITMAP32 res = 0;
BITMAP32 bmp;
BITMAP32 bm;
if (GetObject32A (hnd, sizeof (bmp), &bmp))
{
res = CreateBitmapIndirect32 (&bmp);
SetBitmapBits32 (res, bmp.bmWidthBytes * bmp.bmHeight, bmp.bmBits);
if(!bmp) return 0;
bm = bmp->bitmap;
bm.bmBits = NULL;
res = CreateBitmapIndirect32(&bm);
if(res) {
char *buf = HeapAlloc( GetProcessHeap(), 0, bm.bmWidthBytes *
bm.bmHeight );
GetBitmapBits32 (hbitmap, bm.bmWidthBytes * bm.bmHeight, buf);
SetBitmapBits32 (res, bm.bmWidthBytes * bm.bmHeight, buf);
HeapFree( GetProcessHeap(), 0, buf );
}
GDI_HEAP_UNLOCK( hbitmap );
return res;
}
@ -734,7 +539,7 @@ HICON32 WINAPI CopyImage32( HANDLE32 hnd, UINT32 type, INT32 desiredx,
switch (type)
{
case IMAGE_BITMAP:
return CopyBitmap32(hnd);
return BITMAP_CopyBitmap(hnd);
case IMAGE_ICON:
return CopyIcon32(hnd);
case IMAGE_CURSOR:
@ -879,25 +684,13 @@ HBITMAP32 WINAPI LoadBitmap32A( HINSTANCE32 instance, LPCSTR name )
*/
BOOL32 BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bmp )
{
#ifdef PRELIMINARY_WING16_SUPPORT
if( bmp->bitmap.bmBits )
TSXShmDetach( display, (XShmSegmentInfo*)bmp->bitmap.bmBits );
#endif
TSXFreePixmap( display, bmp->pixmap );
#ifdef PRELIMINARY_WING16_SUPPORT
if( bmp->bitmap.bmBits )
{
__ShmBitmapCtl* p = (__ShmBitmapCtl*)bmp->bitmap.bmBits;
WORD sel = HIWORD(p->bits);
unsigned long l, limit = GetSelectorLimit(sel);
for( l = 0; l < limit; l += 0x10000, sel += __AHINCR )
FreeSelector(sel);
shmctl(p->si.shmid, IPC_RMID, NULL);
shmdt(p->si.shmaddr); /* already marked for destruction */
if( bmp->DDBitmap ) {
if( bmp->DDBitmap->funcs->pDeleteObject )
bmp->DDBitmap->funcs->pDeleteObject( hbitmap );
}
#endif
if( bmp->bitmap.bmBits )
HeapFree( GetProcessHeap(), 0, bmp->bitmap.bmBits );
DIB_DeleteDIBSection( bmp );
@ -922,7 +715,7 @@ INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer )
bmp16.bmWidthBytes = bmp32->bmWidthBytes;
bmp16.bmPlanes = bmp32->bmPlanes;
bmp16.bmBitsPixel = bmp32->bmBitsPixel;
bmp16.bmBits = NULL;
bmp16.bmBits = (SEGPTR)0;
memcpy( buffer, &bmp16, count );
return count;
}
@ -934,8 +727,16 @@ INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer )
}
else
{
if (count > sizeof(bmp->bitmap)) count = sizeof(bmp->bitmap);
memcpy( buffer, &bmp->bitmap, count );
BITMAP16 bmp16;
bmp16.bmType = bmp->bitmap.bmType;
bmp16.bmWidth = bmp->bitmap.bmWidth;
bmp16.bmHeight = bmp->bitmap.bmHeight;
bmp16.bmWidthBytes = bmp->bitmap.bmWidthBytes;
bmp16.bmPlanes = bmp->bitmap.bmPlanes;
bmp16.bmBitsPixel = bmp->bitmap.bmBitsPixel;
bmp16.bmBits = (SEGPTR)0;
if (count > sizeof(bmp16)) count = sizeof(bmp16);
memcpy( buffer, &bmp16, count );
return count;
}
}
@ -962,16 +763,8 @@ INT32 BITMAP_GetObject32( BITMAPOBJ * bmp, INT32 count, LPVOID buffer )
}
else
{
BITMAP32 bmp32;
bmp32.bmType = bmp->bitmap.bmType;
bmp32.bmWidth = bmp->bitmap.bmWidth;
bmp32.bmHeight = bmp->bitmap.bmHeight;
bmp32.bmWidthBytes = bmp->bitmap.bmWidthBytes;
bmp32.bmPlanes = bmp->bitmap.bmPlanes;
bmp32.bmBitsPixel = bmp->bitmap.bmBitsPixel;
bmp32.bmBits = NULL;
if (count > sizeof(bmp32)) count = sizeof(bmp32);
memcpy( buffer, &bmp32, count );
if (count > sizeof(BITMAP32)) count = sizeof(BITMAP32);
memcpy( buffer, &bmp->bitmap, count );
return count;
}
}
@ -1013,7 +806,7 @@ BOOL16 WINAPI GetBitmapDimensionEx16( HBITMAP16 hbitmap, LPSIZE16 size )
{
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
*size = bmp->size;
CONV_SIZE32TO16( &bmp->size, size );
GDI_HEAP_UNLOCK( hbitmap );
return TRUE;
}
@ -1032,8 +825,7 @@ BOOL32 WINAPI GetBitmapDimensionEx32(
{
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
size->cx = (INT32)bmp->size.cx;
size->cy = (INT32)bmp->size.cy;
*size = bmp->size;
GDI_HEAP_UNLOCK( hbitmap );
return TRUE;
}
@ -1058,7 +850,7 @@ BOOL16 WINAPI SetBitmapDimensionEx16( HBITMAP16 hbitmap, INT16 x, INT16 y,
{
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
if (prevSize) *prevSize = bmp->size;
if (prevSize) CONV_SIZE32TO16( &bmp->size, prevSize );
bmp->size.cx = x;
bmp->size.cy = y;
GDI_HEAP_UNLOCK( hbitmap );
@ -1081,9 +873,9 @@ BOOL32 WINAPI SetBitmapDimensionEx32(
{
BITMAPOBJ * bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
if (!bmp) return FALSE;
if (prevSize) CONV_SIZE16TO32( &bmp->size, prevSize );
bmp->size.cx = (INT16)x;
bmp->size.cy = (INT16)y;
if (prevSize) *prevSize = bmp->size;
bmp->size.cx = x;
bmp->size.cy = y;
GDI_HEAP_UNLOCK( hbitmap );
return TRUE;
}

24
objects/brush.c
View File

@ -85,27 +85,13 @@ HBRUSH16 WINAPI CreatePatternBrush16( HBITMAP16 hbitmap )
HBRUSH32 WINAPI CreatePatternBrush32( HBITMAP32 hbitmap )
{
LOGBRUSH32 logbrush = { BS_PATTERN, 0, 0 };
BITMAPOBJ *bmp, *newbmp;
TRACE(gdi, "%04x\n", hbitmap );
/* Make a copy of the bitmap */
if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
return 0;
logbrush.lbHatch = (INT32)CreateBitmapIndirect16( &bmp->bitmap );
newbmp = (BITMAPOBJ *) GDI_GetObjPtr( (HGDIOBJ32)logbrush.lbHatch,
BITMAP_MAGIC );
if (!newbmp)
{
GDI_HEAP_UNLOCK( hbitmap );
return 0;
}
TSXCopyArea( display, bmp->pixmap, newbmp->pixmap, BITMAP_GC(bmp),
0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight, 0, 0 );
GDI_HEAP_UNLOCK( hbitmap );
GDI_HEAP_UNLOCK( logbrush.lbHatch );
return CreateBrushIndirect32( &logbrush );
logbrush.lbHatch = (INT32)BITMAP_CopyBitmap( hbitmap );
if(!logbrush.lbHatch)
return 0;
else
return CreateBrushIndirect32( &logbrush );
}

29
objects/dib.c
View File

@ -67,7 +67,7 @@ BOOL32 DIB_Init(void)
*
* Return the width of an X image in bytes
*/
int DIB_GetXImageWidthBytes( int width, int depth )
int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
{
int i;
@ -144,7 +144,7 @@ int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse )
* Get the info from a bitmap header.
* Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
*/
static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
int *height, WORD *bpp, WORD *compr )
{
if (header->biSize == sizeof(BITMAPINFOHEADER))
@ -1282,11 +1282,18 @@ INT32 WINAPI SetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
}
}
/* 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 = bmp->pixmap;
descr.drawable = pbitmap->pixmap;
descr.gc = BITMAP_GC(bmp);
descr.xSrc = 0;
descr.ySrc = 0;
@ -1294,7 +1301,7 @@ INT32 WINAPI SetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
descr.yDest = height - startscan - lines;
descr.width = bmp->bitmap.bmWidth;
descr.height = lines;
}
EnterCriticalSection( &X11DRV_CritSection );
result = CALL_LARGE_STACK( DIB_SetImageBits, &descr );
LeaveCriticalSection( &X11DRV_CritSection );
@ -1598,8 +1605,12 @@ INT32 WINAPI GetDIBits32(
xend = info->bmiHeader.biWidth;
}
/* HACK for now */
if(!bmp->DDBitmap)
X11DRV_CreateBitmap(hbitmap);
EnterCriticalSection( &X11DRV_CritSection );
bmpImage = (XImage *)CALL_LARGE_STACK( BITMAP_GetXImage, bmp );
bmpImage = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
switch( info->bmiHeader.biBitCount )
{
@ -1822,7 +1833,9 @@ static void DIB_DoUpdateDIBSection( BITMAPOBJ *bmp, BOOL32 toDIB )
descr.nColorMap = dib->nColorMap;
descr.bits = dib->dibSection.dsBm.bmBits;
descr.depth = bmp->bitmap.bmBitsPixel;
descr.drawable = bmp->pixmap;
/* Hack for now */
descr.drawable = ((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap;
descr.gc = BITMAP_GC(bmp);
descr.xSrc = 0;
descr.ySrc = 0;
@ -2062,6 +2075,10 @@ HBITMAP32 WINAPI CreateDIBSection32 (HDC32 hdc, BITMAPINFO *bmi, UINT32 usage,
res = CreateDIBitmap32(hdc, bi, 0, NULL, bmi, usage);
bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC);
if (bmp) bmp->dib = dib;
/* HACK for now */
if(!bmp->DDBitmap)
X11DRV_CreateBitmap(res);
}
/* Create XImage */

14
objects/oembitmap.c
View File

@ -319,6 +319,7 @@ static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
{
HBITMAP16 hbitmap;
BITMAPOBJ * bmpObjPtr;
X11DRV_PHYSBITMAP *pbitmap;
if (!pixmap) return 0;
@ -328,16 +329,19 @@ static HBITMAP16 OBM_MakeBitmap( WORD width, WORD height,
bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
bmpObjPtr->size.cx = width;
bmpObjPtr->size.cy = height;
bmpObjPtr->pixmap = pixmap;
bmpObjPtr->bitmap.bmType = 0;
bmpObjPtr->bitmap.bmWidth = width;
bmpObjPtr->bitmap.bmHeight = height;
bmpObjPtr->bitmap.bmWidthBytes = BITMAP_WIDTH_BYTES( width, bpp );
bmpObjPtr->bitmap.bmPlanes = 1;
bmpObjPtr->bitmap.bmBitsPixel = bpp;
bmpObjPtr->bitmap.bmBits = (SEGPTR)NULL;
bmpObjPtr->bitmap.bmBits = NULL;
bmpObjPtr->dib = NULL;
pbitmap = X11DRV_AllocBitmap(bmpObjPtr);
pbitmap->pixmap = pixmap;
GDI_HEAP_UNLOCK( hbitmap );
return hbitmap;
}
@ -493,10 +497,11 @@ HGLOBAL16 OBM_LoadCursorIcon( WORD id, BOOL32 fCursor )
if (descr.mask)
{
X11DRV_PHYSBITMAP *pbitmapAnd = bmpAnd->DDBitmap->physBitmap;
/* Invert the mask */
TSXSetFunction( display, BITMAP_monoGC, GXinvert );
TSXFillRectangle( display, bmpAnd->pixmap, BITMAP_monoGC, 0, 0,
TSXFillRectangle( display, pbitmapAnd->pixmap, BITMAP_monoGC, 0, 0,
bmpAnd->bitmap.bmWidth, bmpAnd->bitmap.bmHeight );
TSXSetFunction( display, BITMAP_monoGC, GXcopy );
@ -504,11 +509,12 @@ HGLOBAL16 OBM_LoadCursorIcon( WORD id, BOOL32 fCursor )
if (bmpXor->bitmap.bmBitsPixel != 1)
{
X11DRV_PHYSBITMAP *pbitmapXor = bmpXor->DDBitmap->physBitmap;
TSXSetForeground( display, BITMAP_colorGC,
COLOR_ToPhysical( NULL, RGB(0,0,0) ));
TSXSetBackground( display, BITMAP_colorGC, 0 );
TSXSetFunction( display, BITMAP_colorGC, GXor );
TSXCopyPlane(display, bmpAnd->pixmap, bmpXor->pixmap, BITMAP_colorGC,
TSXCopyPlane(display, pbitmapAnd->pixmap, pbitmapXor->pixmap, BITMAP_colorGC,
0, 0, bmpXor->bitmap.bmWidth, bmpXor->bitmap.bmHeight,
0, 0, 1 );
TSXSetFunction( display, BITMAP_colorGC, GXcopy );

13
windows/graphics.c
View File

@ -71,6 +71,7 @@ BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap,
BITMAPOBJ *bmp;
DC *dc;
BOOL32 ret = TRUE;
X11DRV_PHYSBITMAP *pbitmap;
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
@ -79,6 +80,8 @@ BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap,
return FALSE;
}
pbitmap = bmp->DDBitmap->physBitmap;
xdest += dc->w.DCOrgX; ydest += dc->w.DCOrgY;
TSXSetFunction( display, dc->u.x.gc, GXcopy );
@ -86,7 +89,7 @@ BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap,
{
TSXSetForeground( display, dc->u.x.gc, dc->u.x.backgroundPixel );
TSXSetBackground( display, dc->u.x.gc, dc->u.x.textPixel );
TSXCopyPlane( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc,
TSXCopyPlane( display, pbitmap->pixmap, dc->u.x.drawable, dc->u.x.gc,
xsrc, ysrc, width, height, xdest, ydest, 1 );
}
else if (bmp->bitmap.bmBitsPixel == dc->w.bitsPerPixel)
@ -105,12 +108,12 @@ BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap,
TSXSetForeground(display, dc->u.x.gc, dc->u.x.textPixel);
TSXSetBackground(display, dc->u.x.gc, dc->u.x.backgroundPixel);
}
TSXCopyPlane( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc,
TSXCopyPlane( display, pbitmap->pixmap, dc->u.x.drawable, dc->u.x.gc,
xsrc, ysrc, width, height, xdest, ydest, plane );
}
else
{
TSXCopyArea( display, bmp->pixmap, dc->u.x.drawable,
TSXCopyArea( display, pbitmap->pixmap, dc->u.x.drawable,
dc->u.x.gc, xsrc, ysrc, width, height, xdest, ydest );
}
}
@ -235,6 +238,7 @@ BOOL32 GRAPH_SelectClipMask( HDC32 hdc, HBITMAP32 hMonoBitmap, INT32 x, INT32 y)
{
BITMAPOBJ *bmp = NULL;
DC *dc;
X11DRV_PHYSBITMAP *pbitmap = NULL;
if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE;
if ( hMonoBitmap )
@ -245,10 +249,11 @@ BOOL32 GRAPH_SelectClipMask( HDC32 hdc, HBITMAP32 hMonoBitmap, INT32 x, INT32 y)
GDI_HEAP_UNLOCK( hdc );
return FALSE;
}
pbitmap = bmp->DDBitmap->physBitmap;
TSXSetClipOrigin( display, dc->u.x.gc, dc->w.DCOrgX + x, dc->w.DCOrgY + y);
}
TSXSetClipMask( display, dc->u.x.gc, (bmp) ? bmp->pixmap : None );
TSXSetClipMask( display, dc->u.x.gc, (bmp) ? pbitmap->pixmap : None );
GDI_HEAP_UNLOCK( hdc );
GDI_HEAP_UNLOCK( hMonoBitmap );