Moved more things to the X11 driver.
[wine] / graphics / x11drv / bitmap.c
1 /*
2  * X11DRV bitmap objects
3  *
4  * Copyright 1993 Alexandre Julliard
5  */
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include "ts_xlib.h"
10 #include "ts_xutil.h"
11 #include "gdi.h"
12 #include "callback.h"
13 #include "dc.h"
14 #include "bitmap.h"
15 #include "heap.h"
16 #include "debug.h"
17 #include "xmalloc.h"
18 #include "x11drv.h"
19
20   /* GCs used for B&W and color bitmap operations */
21 GC BITMAP_monoGC = 0, BITMAP_colorGC = 0;
22
23
24 /***********************************************************************
25  *           X11DRV_BITMAP_Init
26  */
27 BOOL32 X11DRV_BITMAP_Init(void)
28 {
29     Pixmap tmpPixmap;
30     
31       /* Create the necessary GCs */
32     
33     if ((tmpPixmap = TSXCreatePixmap( display, rootWindow, 1, 1, 1 )))
34     {
35         BITMAP_monoGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
36         TSXSetGraphicsExposures( display, BITMAP_monoGC, False );
37         TSXFreePixmap( display, tmpPixmap );
38     }
39
40     if (screenDepth != 1)
41     {
42         if ((tmpPixmap = TSXCreatePixmap(display, rootWindow, 1,1,screenDepth)))
43         {
44             BITMAP_colorGC = TSXCreateGC( display, tmpPixmap, 0, NULL );
45             TSXSetGraphicsExposures( display, BITMAP_colorGC, False );
46             TSXFreePixmap( display, tmpPixmap );
47         }
48     }
49     return TRUE;
50 }
51
52 /***********************************************************************
53  *           X11DRV_BITMAP_SelectObject
54  */
55 HBITMAP32 X11DRV_BITMAP_SelectObject( DC * dc, HBITMAP32 hbitmap,
56                                       BITMAPOBJ * bmp )
57 {
58     HRGN32 hrgn;
59     HBITMAP32 prevHandle = dc->w.hBitmap;
60     X11DRV_PHYSBITMAP *pbitmap;
61     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
62
63
64     if (!(dc->w.flags & DC_MEMORY)) return 0;
65
66     if(!bmp->DDBitmap)
67         if(!X11DRV_CreateBitmap(hbitmap))
68             return 0;
69
70     if(bmp->DDBitmap->funcs != dc->funcs) {
71         WARN(x11drv, "Trying to select non-X11 DDB into an X11 dc\n");
72         return 0;
73     }
74
75     pbitmap = bmp->DDBitmap->physBitmap;
76
77     dc->w.totalExtent.left   = 0;
78     dc->w.totalExtent.top    = 0;
79     dc->w.totalExtent.right  = bmp->bitmap.bmWidth;
80     dc->w.totalExtent.bottom = bmp->bitmap.bmHeight;
81
82     if (dc->w.hVisRgn)
83        SetRectRgn32( dc->w.hVisRgn, 0, 0,
84                      bmp->bitmap.bmWidth, bmp->bitmap.bmHeight );
85     else
86     { 
87        hrgn = CreateRectRgn32(0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight);
88        if (!hrgn) return 0;
89        dc->w.hVisRgn    = hrgn;
90     }
91
92     physDev->drawable = pbitmap->pixmap;
93     dc->w.hBitmap     = hbitmap;
94
95       /* Change GC depth if needed */
96
97     if (dc->w.bitsPerPixel != bmp->bitmap.bmBitsPixel)
98     {
99         TSXFreeGC( display, physDev->gc );
100         physDev->gc = TSXCreateGC( display, physDev->drawable, 0, NULL );
101         dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
102         DC_InitDC( dc );
103     }
104     else CLIPPING_UpdateGCRegion( dc );  /* Just update GC clip region */
105     return prevHandle;
106 }
107
108
109 /***********************************************************************
110  *           XPutImage_wrapper
111  *
112  * Wrapper to call XPutImage with CALL_LARGE_STACK.
113  */
114
115 struct XPutImage_descr
116 {
117     BITMAPOBJ *bmp;
118     XImage    *image;
119     INT32      width;
120     INT32      height;
121 };
122
123 static int XPutImage_wrapper( const struct XPutImage_descr *descr )
124 {
125     return XPutImage( display,
126                ((X11DRV_PHYSBITMAP *)descr->bmp->DDBitmap->physBitmap)->pixmap,
127                BITMAP_GC(descr->bmp),
128                descr->image, 0, 0, 0, 0, descr->width, descr->height );
129 }
130
131
132 /***************************************************************************
133  *
134  *      X11DRV_AllocBitmap
135  *
136  * Allocate DDBitmap and physBitmap
137  *
138  */
139 X11DRV_PHYSBITMAP *X11DRV_AllocBitmap( BITMAPOBJ *bmp )
140 {
141     X11DRV_PHYSBITMAP *pbitmap;
142
143     if(!(bmp->DDBitmap = HeapAlloc(GetProcessHeap(), 0, sizeof(DDBITMAP)))) {
144         WARN(x11drv, "Can't alloc DDBITMAP\n");
145         return NULL;
146     }
147
148     if(!(pbitmap = HeapAlloc(GetProcessHeap(), 0,sizeof(X11DRV_PHYSBITMAP)))) {
149         WARN(x11drv, "Can't alloc X11DRV_PHYSBITMAP\n");
150         HeapFree(GetProcessHeap(), 0, bmp->DDBitmap);
151         return NULL;
152     }
153
154     bmp->DDBitmap->physBitmap = pbitmap;
155     bmp->DDBitmap->funcs = DRIVER_FindDriver( "DISPLAY" );
156     return pbitmap;
157 }
158
159
160 /****************************************************************************
161  *
162  *        X11DRV_CreateBitmap
163  *
164  * Create a device dependent X11 bitmap
165  *
166  * Returns TRUE on success else FALSE
167  *
168  */
169
170 BOOL32 X11DRV_CreateBitmap( HBITMAP32 hbitmap )
171 {
172     X11DRV_PHYSBITMAP *pbitmap;
173     BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
174
175     if(!bmp) {
176         WARN(x11drv, "Bad bitmap handle %08x\n", hbitmap);
177         return FALSE;
178     }
179
180       /* Check parameters */
181     if (bmp->bitmap.bmPlanes != 1) return 0;
182     if ((bmp->bitmap.bmBitsPixel != 1) && 
183         (bmp->bitmap.bmBitsPixel != screenDepth)) {
184         ERR(x11drv, "Trying to make bitmap with planes=%d, bpp=%d\n",
185             bmp->bitmap.bmPlanes, bmp->bitmap.bmBitsPixel);
186         GDI_HEAP_UNLOCK( hbitmap );
187         return FALSE;
188     }
189
190     TRACE(x11drv, "(%08x) %dx%d %d bpp\n", hbitmap, bmp->bitmap.bmWidth,
191           bmp->bitmap.bmHeight, bmp->bitmap.bmBitsPixel);
192
193     pbitmap = X11DRV_AllocBitmap( bmp );
194     if(!pbitmap) return FALSE;
195
196       /* Create the pixmap */
197     pbitmap->pixmap = TSXCreatePixmap(display, rootWindow, bmp->bitmap.bmWidth,
198                               bmp->bitmap.bmHeight, bmp->bitmap.bmBitsPixel);
199     if (!pbitmap->pixmap) {
200         WARN(x11drv, "Can't create Pixmap\n");
201         HeapFree(GetProcessHeap(), 0, bmp->DDBitmap->physBitmap);
202         HeapFree(GetProcessHeap(), 0, bmp->DDBitmap);
203         GDI_HEAP_UNLOCK( hbitmap );
204         return FALSE;
205     }
206
207     if (bmp->bitmap.bmBits) /* Set bitmap bits */
208         X11DRV_BitmapBits( hbitmap, bmp->bitmap.bmBits,
209                            bmp->bitmap.bmHeight * bmp->bitmap.bmWidthBytes,
210                            DDB_SET );
211
212     GDI_HEAP_UNLOCK( hbitmap );
213     return TRUE;
214 }
215
216
217 /***********************************************************************
218  *           X11DRV_BITMAP_GetXImage
219  *
220  * Get an X image for a bitmap. For use with CALL_LARGE_STACK.
221  */
222 XImage *X11DRV_BITMAP_GetXImage( const BITMAPOBJ *bmp )
223 {
224     return XGetImage( display,
225                       ((X11DRV_PHYSBITMAP *)bmp->DDBitmap->physBitmap)->pixmap,
226                       0, 0, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
227                       AllPlanes, ZPixmap );
228 }
229
230
231 /***********************************************************************
232  *           X11DRV_GetBitmapBits
233  * 
234  * RETURNS
235  *    Success: Number of bytes copied
236  *    Failure: 0
237  */
238 static LONG X11DRV_GetBitmapBits(BITMAPOBJ *bmp, void *buffer, LONG count)
239 {
240     LONG old_height, height;
241     XImage *image;
242     LPBYTE tbuf;
243     int h, w, pad;
244
245     TRACE(x11drv, "(bmp=%p, buffer=%p, count=0x%lx)\n", bmp, buffer, count);
246
247     pad = BITMAP_GetPadding(bmp->bitmap.bmWidth, bmp->bitmap.bmBitsPixel);
248
249     if (pad == -1)
250         return 0;
251
252     EnterCriticalSection( &X11DRV_CritSection );
253
254     /* Hack: change the bitmap height temporarily to avoid */
255     /*       getting unnecessary bitmap rows. */
256
257     old_height = bmp->bitmap.bmHeight;
258     height = bmp->bitmap.bmHeight = count / bmp->bitmap.bmWidthBytes;
259
260     image = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
261
262     bmp->bitmap.bmHeight = old_height;
263
264     /* copy XImage to 16 bit padded image buffer with real bitsperpixel */
265
266     tbuf = buffer;
267     switch (bmp->bitmap.bmBitsPixel)
268     {
269     case 1:
270         for (h=0;h<height;h++)
271         {
272             *tbuf = 0;
273             for (w=0;w<bmp->bitmap.bmWidth;w++)
274             {
275                 if ((w%8) == 0)
276                     *tbuf = 0;
277                 *tbuf |= XGetPixel(image,w,h)<<(7-(w&7));
278                 if ((w&7) == 7) ++tbuf;
279             }
280             tbuf += pad;
281         }
282         break;
283     case 4:
284         for (h=0;h<height;h++)
285         {
286             for (w=0;w<bmp->bitmap.bmWidth;w++)
287             {
288                 if (!(w & 1)) *tbuf = XGetPixel( image, w, h) << 4;
289                 else *tbuf++ |= XGetPixel( image, w, h) & 0x0f;
290             }
291             tbuf += pad;
292         }
293         break;
294     case 8:
295         for (h=0;h<height;h++)
296         {
297             for (w=0;w<bmp->bitmap.bmWidth;w++)
298                 *tbuf++ = XGetPixel(image,w,h);
299             tbuf += pad;
300         }
301         break;
302     case 15:
303     case 16:
304         for (h=0;h<height;h++)
305         {
306             for (w=0;w<bmp->bitmap.bmWidth;w++)
307             {
308                 long pixel = XGetPixel(image,w,h);
309
310                 *tbuf++ = pixel & 0xff;
311                 *tbuf++ = (pixel>>8) & 0xff;
312             }
313         }
314         break;
315     case 24:
316         for (h=0;h<height;h++)
317         {
318             for (w=0;w<bmp->bitmap.bmWidth;w++)
319             {
320                 long pixel = XGetPixel(image,w,h);
321
322                 *tbuf++ = pixel & 0xff;
323                 *tbuf++ = (pixel>> 8) & 0xff;
324                 *tbuf++ = (pixel>>16) & 0xff;
325             }
326             tbuf += pad;
327         }
328         break;
329
330     case 32:
331         for (h=0;h<height;h++)
332         {
333             for (w=0;w<bmp->bitmap.bmWidth;w++)
334             {
335                 long pixel = XGetPixel(image,w,h);
336
337                 *tbuf++ = pixel & 0xff;
338                 *tbuf++ = (pixel>> 8) & 0xff;
339                 *tbuf++ = (pixel>>16) & 0xff;
340                 *tbuf++ = (pixel>>24) & 0xff;
341             }
342             tbuf += pad;
343         }
344         break;
345     default:
346         FIXME(x11drv, "Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
347     }
348     XDestroyImage( image );
349     LeaveCriticalSection( &X11DRV_CritSection );
350
351     return count;
352 }
353
354
355
356 /******************************************************************************
357  *             X11DRV_SetBitmapBits
358  *
359  * RETURNS
360  *    Success: Number of bytes used in setting the bitmap bits
361  *    Failure: 0
362  */
363 static LONG X11DRV_SetBitmapBits(BITMAPOBJ *bmp, void *bits, LONG count)
364 {
365     struct XPutImage_descr descr;
366     LONG height;
367     XImage *image;
368     LPBYTE sbuf;
369     int w, h, pad;
370
371     TRACE(x11drv, "(bmp=%p, bits=%p, count=0x%lx)\n", bmp, bits, count);
372     
373     pad = BITMAP_GetPadding(bmp->bitmap.bmWidth, bmp->bitmap.bmBitsPixel);
374
375     if (pad == -1) 
376         return 0;
377         
378     sbuf = (LPBYTE)bits;
379
380     height = count / bmp->bitmap.bmWidthBytes;
381
382     EnterCriticalSection( &X11DRV_CritSection );
383     image = XCreateImage( display, DefaultVisualOfScreen(screen),
384                           bmp->bitmap.bmBitsPixel, ZPixmap, 0, NULL,
385                           bmp->bitmap.bmWidth, height, 32, 0 );
386     image->data = (LPBYTE)xmalloc(image->bytes_per_line * height);
387     
388     /* copy 16 bit padded image buffer with real bitsperpixel to XImage */
389     sbuf = (LPBYTE)bits;
390     switch (bmp->bitmap.bmBitsPixel)
391     {
392     case 1:
393         for (h=0;h<height;h++)
394         {
395             for (w=0;w<bmp->bitmap.bmWidth;w++)
396             {
397                 XPutPixel(image,w,h,(sbuf[0]>>(7-(w&7))) & 1);
398                 if ((w&7) == 7)
399                     sbuf++;
400             }
401             sbuf += pad;
402         }
403         break;
404     case 4:
405         for (h=0;h<height;h++)
406         {
407             for (w=0;w<bmp->bitmap.bmWidth;w++)
408             {
409                 if (!(w & 1)) XPutPixel( image, w, h, *sbuf >> 4 );
410                 else XPutPixel( image, w, h, *sbuf++ & 0xf );
411             }
412             sbuf += pad;
413         }
414         break;
415     case 8:
416         for (h=0;h<height;h++)
417         {
418             for (w=0;w<bmp->bitmap.bmWidth;w++)
419                 XPutPixel(image,w,h,*sbuf++);
420             sbuf += pad;
421         }
422         break;
423     case 15:
424     case 16:
425         for (h=0;h<height;h++)
426         {
427             for (w=0;w<bmp->bitmap.bmWidth;w++)
428             {
429                 XPutPixel(image,w,h,sbuf[1]*256+sbuf[0]);
430                 sbuf+=2;
431             }
432         }
433         break;
434     case 24: 
435         for (h=0;h<height;h++)
436         {
437             for (w=0;w<bmp->bitmap.bmWidth;w++)
438             {
439                 XPutPixel(image,w,h,(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
440                 sbuf += 3;
441             }
442             sbuf += pad;
443         }
444         break;
445     case 32: 
446         for (h=0;h<height;h++)
447         {
448             for (w=0;w<bmp->bitmap.bmWidth;w++)
449             {
450                 XPutPixel(image,w,h,(sbuf[3]<<24)+(sbuf[2]<<16)+(sbuf[1]<<8)+sbuf[0]);
451                 sbuf += 4;
452             }
453             sbuf += pad;
454         }
455         break;
456     default:
457       FIXME(x11drv, "Unhandled bits:%d\n", bmp->bitmap.bmBitsPixel);
458
459     }
460
461     descr.bmp    = bmp;
462     descr.image  = image;
463     descr.width  = bmp->bitmap.bmWidth;
464     descr.height = height;
465
466     CALL_LARGE_STACK( XPutImage_wrapper, &descr );
467     XDestroyImage( image ); /* frees image->data too */
468     LeaveCriticalSection( &X11DRV_CritSection );
469     
470     return count;
471 }
472
473 /***********************************************************************
474  *           X11DRV_BitmapBits
475  */
476 LONG X11DRV_BitmapBits(HBITMAP32 hbitmap, void *bits, LONG count, WORD flags)
477 {
478     BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC );
479     LONG ret;
480     if(!bmp) {
481         WARN(x11drv, "Bad bitmap handle %08x\n", hbitmap);
482         return FALSE;
483     }
484
485     if(flags == DDB_GET)
486         ret = X11DRV_GetBitmapBits(bmp, bits, count);
487     else if(flags == DDB_SET)
488         ret = X11DRV_SetBitmapBits(bmp, bits, count);
489     else {
490         ERR(x11drv, "Unknown flags value %d\n", flags);
491         ret = 0;
492     }
493     
494     GDI_HEAP_UNLOCK( hbitmap );
495     return ret;
496 }
497
498 /***********************************************************************
499  *           X11DRV_BITMAP_DeleteObject
500  */
501 BOOL32 X11DRV_BITMAP_DeleteObject( HBITMAP32 hbitmap, BITMAPOBJ * bmp )
502 {
503     X11DRV_PHYSBITMAP *pbitmap = bmp->DDBitmap->physBitmap;
504
505     TSXFreePixmap( display, pbitmap->pixmap );
506
507     HeapFree( GetProcessHeap(), 0, bmp->DDBitmap->physBitmap );
508     HeapFree( GetProcessHeap(), 0, bmp->DDBitmap );
509     bmp->DDBitmap = NULL;
510
511     return TRUE;
512 }