objects/dib.c

   1 /*
   2  * GDI device-independent bitmaps
   3  *
   4  * Copyright 1993,1994  Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <X11/Xlib.h>
  10 #include <X11/Xutil.h>
  11 #include "dc.h"
  12 #include "bitmap.h"
  13 #include "callback.h"
  14 #include "palette.h"
  15 #include "stddebug.h"
  16 #include "color.h"
  17 #include "debug.h"
  18
  19 extern void CLIPPING_UpdateGCRegion(DC* );
  20
  21 /***********************************************************************
  22  *           DIB_GetImageWidthBytes
  23  *
  24  * Return the width of an X image in bytes
  25  */
  26 int DIB_GetImageWidthBytes( int width, int depth )
  27 {
  28     int words;
  29
  30     switch(depth)
  31     {
  32     case 1:  words = (width + 31) / 32; break;
  33     case 4:  words = (width + 7) / 8; break;
  34     case 8:  words = (width + 3) / 4; break;
  35     case 15:
  36     case 16: words = (width + 1) / 2; break;
  37     case 24: words = width; break;
  38     default:
  39         fprintf(stderr, "DIB: unsupported depth %d.\n", depth );
  40         exit(1);
  41     }
  42     return 4 * words;
  43 }
  44
  45
  46 /***********************************************************************
  47  *           DIB_BitmapInfoSize
  48  *
  49  * Return the size of the bitmap info structure.
  50  */
  51 int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse )
  52 {
  53     int colors;
  54
  55     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
  56     {
  57         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)info;
  58         colors = (core->bcBitCount != 24) ? 1 << core->bcBitCount : 0;
  59         return sizeof(BITMAPCOREHEADER) + colors *
  60              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
  61     }
  62     else  /* assume BITMAPINFOHEADER */
  63     {
  64         colors = info->bmiHeader.biClrUsed;
  65         if (!colors && (info->bmiHeader.biBitCount != 24))
  66             colors = 1 << info->bmiHeader.biBitCount;
  67         return sizeof(BITMAPINFOHEADER) + colors *
  68                ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
  69     }
  70 }
  71
  72
  73 /***********************************************************************
  74  *           DIB_DIBmpToImage
  75  *
  76  * Create an XImage pointing to the bitmap data.
  77  */
  78 static XImage *DIB_DIBmpToImage( BITMAPINFOHEADER * bmp, void * bmpData )
  79 {
  80     extern void _XInitImageFuncPtrs( XImage* );
  81     XImage * image;
  82
  83     image = XCreateImage(display, DefaultVisualOfScreen( screen ),
  84                          bmp->biBitCount, ZPixmap, 0, bmpData,
  85                          bmp->biWidth, bmp->biHeight, 32,
  86                          DIB_GetImageWidthBytes(bmp->biWidth,bmp->biBitCount));
  87     if (!image) return 0;
  88     image->byte_order = MSBFirst;
  89     image->bitmap_bit_order = MSBFirst;
  90     image->bitmap_unit = 16;
  91     _XInitImageFuncPtrs(image);
  92     return image;
  93 }
  94
  95
  96 /***********************************************************************
  97  *           DIB_GetBitmapInfo
  98  *
  99  * Get the info from a bitmap header.
 100  * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
 101  */
 102 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
 103                               DWORD *height, WORD *bpp )
 104 {
 105     if (header->biSize == sizeof(BITMAPINFOHEADER))
 106     {
 107         *width  = header->biWidth;
 108         *height = header->biHeight;
 109         *bpp    = header->biBitCount;
 110         return 1;
 111     }
 112     if (header->biSize == sizeof(BITMAPCOREHEADER))
 113     {
 114         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header;
 115         *width  = core->bcWidth;
 116         *height = core->bcHeight;
 117         *bpp    = core->bcBitCount;
 118         return 0;
 119     }
 120     fprintf( stderr, "DIB_GetBitmapInfo: wrong size (%ld) for header\n",
 121              header->biSize );
 122     return -1;
 123 }
 124
 125
 126 /***********************************************************************
 127  *           DIB_BuildColorMap
 128  *
 129  * Build the color map from the bitmap palette. Should not be called
 130  * for a 24-bit deep bitmap.
 131  */
 132 static int *DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth,
 133                                BITMAPINFO *info )
 134 {
 135     int i, colors;
 136     BOOL32 isInfo;
 137     WORD *colorPtr;
 138     int *colorMapping;
 139
 140     if ((isInfo = (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))))
 141     {
 142         colors = info->bmiHeader.biClrUsed;
 143         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
 144         colorPtr = (WORD *)info->bmiColors;
 145     }
 146     else  /* assume BITMAPCOREINFO */
 147     {
 148         colors = 1 << ((BITMAPCOREHEADER *)&info->bmiHeader)->bcBitCount;
 149         colorPtr = (WORD *)((BITMAPCOREINFO *)info)->bmciColors;
 150     }
 151     if (!(colorMapping = (int *)malloc( colors * sizeof(int) ))) return NULL;
 152
 153     if (coloruse == DIB_RGB_COLORS)
 154     {
 155         if (isInfo)
 156         {
 157             RGBQUAD * rgb = (RGBQUAD *)colorPtr;
 158
 159             if (depth == 1)  /* Monochrome */
 160                 for (i = 0; i < colors; i++, rgb++)
 161                     colorMapping[i] = (rgb->rgbRed + rgb->rgbGreen +
 162                                        rgb->rgbBlue > 255*3/2);
 163             else
 164                 for (i = 0; i < colors; i++, rgb++)
 165                     colorMapping[i] = COLOR_ToPhysical( dc, RGB(rgb->rgbRed,
 166                                                                 rgb->rgbGreen,
 167                                                                 rgb->rgbBlue));
 168         }
 169         else
 170         {
 171             RGBTRIPLE * rgb = (RGBTRIPLE *)colorPtr;
 172
 173             if (depth == 1)  /* Monochrome */
 174                 for (i = 0; i < colors; i++, rgb++)
 175                     colorMapping[i] = (rgb->rgbtRed + rgb->rgbtGreen +
 176                                        rgb->rgbtBlue > 255*3/2);
 177             else
 178                 for (i = 0; i < colors; i++, rgb++)
 179                     colorMapping[i] = COLOR_ToPhysical( dc, RGB(rgb->rgbtRed,
 180                                                                rgb->rgbtGreen,
 181                                                                rgb->rgbtBlue));
 182         }
 183     }
 184     else  /* DIB_PAL_COLORS */
 185     {
 186         for (i = 0; i < colors; i++, colorPtr++)
 187             colorMapping[i] = COLOR_ToPhysical( dc, PALETTEINDEX(*colorPtr) );
 188     }
 189     return colorMapping;
 190 }
 191
 192
 193 /***********************************************************************
 194  *           DIB_SetImageBits_1
 195  *
 196  * SetDIBits for a 1-bit deep DIB.
 197  */
 198 static void DIB_SetImageBits_1( DWORD lines, BYTE *bits, DWORD width,
 199                                 int *colors, XImage *bmpImage )
 200 {
 201     DWORD i, x;
 202     BYTE pad, pix;
 203
 204     if (!(width & 31)) pad = 0;
 205     else pad = ((32 - (width & 31)) + 7) / 8;
 206
 207     while (lines--)
 208     {
 209         for (i = width/8, x = 0; (i > 0); i--)
 210         {
 211             pix = *bits++;
 212             XPutPixel( bmpImage, x++, lines, colors[pix >> 7] );
 213             XPutPixel( bmpImage, x++, lines, colors[(pix >> 6) & 1] );
 214             XPutPixel( bmpImage, x++, lines, colors[(pix >> 5) & 1] );
 215             XPutPixel( bmpImage, x++, lines, colors[(pix >> 4) & 1] );
 216             XPutPixel( bmpImage, x++, lines, colors[(pix >> 3) & 1] );
 217             XPutPixel( bmpImage, x++, lines, colors[(pix >> 2) & 1] );
 218             XPutPixel( bmpImage, x++, lines, colors[(pix >> 1) & 1] );
 219             XPutPixel( bmpImage, x++, lines, colors[pix & 1] );
 220         }
 221         pix = *bits;
 222         switch(width & 7)
 223         {
 224         case 7: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 225         case 6: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 226         case 5: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 227         case 4: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 228         case 3: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 229         case 2: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 230         case 1: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] );
 231         }
 232         bits += pad;
 233     }
 234 }
 235
 236
 237 /***********************************************************************
 238  *           DIB_SetImageBits_4
 239  *
 240  * SetDIBits for a 4-bit deep DIB.
 241  */
 242 static void DIB_SetImageBits_4( DWORD lines, BYTE *bits, DWORD width,
 243                                 int *colors, XImage *bmpImage )
 244 {
 245     DWORD i, x;
 246     BYTE pad;
 247
 248     if (!(width & 7)) pad = 0;
 249     else pad = ((8 - (width & 7)) + 1) / 2;
 250
 251     while (lines--)
 252     {
 253         for (i = width/2, x = 0; i > 0; i--)
 254         {
 255             BYTE pix = *bits++;
 256             XPutPixel( bmpImage, x++, lines, colors[pix >> 4] );
 257             XPutPixel( bmpImage, x++, lines, colors[pix & 0x0f] );
 258         }
 259         if (width & 1) XPutPixel( bmpImage, x, lines, colors[*bits >> 4] );
 260         bits += pad;
 261     }
 262 }
 263
 264 #define check_xy(x,y) \
 265         if (x > width) { \
 266                 x = 0; \
 267                 if (lines) \
 268                         lines--; \
 269         }
 270
 271 /***********************************************************************
 272  *           DIB_SetImageBits_RLE4
 273  *
 274  * SetDIBits for a 4-bit deep compressed DIB.
 275  */
 276 static void DIB_SetImageBits_RLE4( DWORD lines, BYTE *bits, DWORD width,
 277                                    int *colors, XImage *bmpImage )
 278 {
 279         int x = 0, c, length;
 280         BYTE *begin = bits;
 281
 282         lines--;
 283         while ((int)lines >= 0)
 284         {
 285                 length = *bits++;
 286                 if (length) {   /* encoded */
 287                         c = *bits++;
 288                         while (length--) {
 289                                 XPutPixel(bmpImage, x++, lines, colors[c >> 4]);
 290                                 check_xy(x, y);
 291                                 if (length) {
 292                                         length--;
 293                                         XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
 294                                         check_xy(x, y);
 295                                 }
 296                         }
 297                 } else {
 298                         length = *bits++;
 299                         switch (length) {
 300                                 case 0: /* eol */
 301                                         x = 0;
 302                                         lines--;
 303                                         continue;
 304
 305                                 case 1: /* eopicture */
 306                                         return;
 307
 308                                 case 2: /* delta */
 309                                         x += *bits++;
 310                                         lines -= *bits++;
 311                                         continue;
 312
 313                                 default: /* absolute */
 314                                         while (length--) {
 315                                                 c = *bits++;
 316                                                 XPutPixel(bmpImage, x++, lines, colors[c >> 4]);
 317                                                 check_xy(x, y);
 318                                                 if (length) {
 319                                                         length--;
 320                                                         XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
 321                                                         check_xy(x, y);
 322                                                 }
 323                                         }
 324                                         if ((bits - begin) & 1)
 325                                                 bits++;
 326                         }
 327                 }
 328         }
 329 }
 330
 331 /***********************************************************************
 332  *           DIB_SetImageBits_8
 333  *
 334  * SetDIBits for an 8-bit deep DIB.
 335  */
 336 static void DIB_SetImageBits_8( DWORD lines, BYTE *bits, DWORD width,
 337                                 int *colors, XImage *bmpImage )
 338 {
 339     DWORD x;
 340     BYTE pad = (4 - (width & 3)) & 3;
 341
 342     while (lines--)
 343     {
 344         for (x = 0; x < width; x++)
 345             XPutPixel( bmpImage, x, lines, colors[*bits++] );
 346         bits += pad;
 347     }
 348 }
 349
 350 /***********************************************************************
 351  *            DIB_SetImageBits_RLE8
 352  *
 353  * SetDIBits for an 8-bit deep compressed DIB.
 354  *
 355  * This function rewritten 941113 by James Youngman.  WINE blew out when I
 356  * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
 357  *
 358  * This was because the algorithm assumed that all RLE8 bitmaps end with the
 359  * 'End of bitmap' escape code.  This code is very much laxer in what it
 360  * allows to end the expansion.  Possibly too lax.  See the note by
 361  * case RleDelta.  BTW, MS's documentation implies that a correct RLE8
 362  * bitmap should end with RleEnd, but on the other hand, software exists
 363  * that produces ones that don't and Windows 3.1 doesn't complain a bit
 364  * about it.
 365  *
 366  * (No) apologies for my English spelling.  [Emacs users: c-indent-level=4].
 367  *                      James A. Youngman <mbcstjy@afs.man.ac.uk>
 368  *                                              [JAY]
 369  */
 370
 371 enum Rle8_EscapeCodes
 372 {
 373   /*
 374    * Apologies for polluting your file's namespace...
 375    */
 376   RleEol        = 0,            /* End of line */
 377   RleEnd        = 1,            /* End of bitmap */
 378   RleDelta      = 2             /* Delta */
 379 };
 380
 381 static void DIB_SetImageBits_RLE8( DWORD lines, BYTE *bits, DWORD width,
 382                                    int *colors, XImage *bmpImage )
 383 {
 384     int x;                      /* X-positon on each line.  Increases. */
 385     int line;                   /* Line #.  Starts at lines-1, decreases */
 386     BYTE *pIn = bits;           /* Pointer to current position in bits */
 387     BYTE length;                /* The length pf a run */
 388     BYTE color_index;           /* index into colors[] as read from bits */
 389     BYTE escape_code;           /* See enum Rle8_EscapeCodes.*/
 390     WORD color;                 /* value of colour[color_index] */
 391
 392     if (lines == 0)             /* Let's hope this doesn't happen. */
 393       return;
 394
 395     /*
 396      * Note that the bitmap data is stored by Windows starting at the
 397      * bottom line of the bitmap and going upwards.  Within each line,
 398      * the data is stored left-to-right.  That's the reason why line
 399      * goes from lines-1 to 0.                  [JAY]
 400      */
 401
 402     x = 0;
 403     line = lines-1;
 404     do
 405       {
 406           length = *pIn++;
 407
 408           /*
 409            * If the length byte is not zero (which is the escape value),
 410            * We have a run of length pixels all the same colour.  The colour
 411            * index is stored next.
 412            *
 413            * If the length byte is zero, we need to read the next byte to
 414            * know what to do.                   [JAY]
 415            */
 416           if (length != 0)
 417             {
 418                 /*
 419                  * [Run-Length] Encoded mode
 420                  */
 421                 color_index = (*pIn++); /* Get the colour index. */
 422                 color = colors[color_index];
 423
 424                 while(length--)
 425                   XPutPixel(bmpImage, x++, line, color);
 426             }
 427           else
 428             {
 429                 /*
 430                  * Escape codes (may be an absolute sequence though)
 431                  */
 432                 escape_code = (*pIn++);
 433                 switch(escape_code)
 434                   {
 435                     case RleEol: /* =0, end of line */
 436                       {
 437                           x = 0;
 438                           line--;
 439                           break;
 440                       }
 441
 442                     case RleEnd: /* =1, end of bitmap */
 443                       {
 444                           /*
 445                            * Not all RLE8 bitmaps end with this
 446                            * code.  For example, Paint Shop Pro
 447                            * produces some that don't.  That's (I think)
 448                            * what caused the previous implementation to
 449                            * fail.                      [JAY]
 450                            */
 451                           line=-1; /* Cause exit from do loop. */
 452                           break;
 453                       }
 454
 455                     case RleDelta: /* =2, a delta */
 456                       {
 457                           /*
 458                            * Note that deltaing to line 0
 459                            * will cause an exit from the loop,
 460                            * which may not be what is intended.
 461                            * The fact that there is a delta in the bits
 462                            * almost certainly implies that there is data
 463                            * to follow.  You may feel that we should
 464                            * jump to the top of the loop to avoid exiting
 465                            * in this case.
 466                            *
 467                            * TODO: Decide what to do here in that case. [JAY]
 468                            */
 469                           x     += (*pIn++);
 470                           line  -= (*pIn++);
 471                           if (line == 0)
 472                             {
 473                               dprintf_bitmap(stddeb,
 474                                              "DIB_SetImageBits_RLE8(): "
 475                                              "Delta to last line of bitmap "
 476                                              "(wrongly?) causes loop exit\n");
 477                             }
 478                           break;
 479                       }
 480
 481                     default:    /* >2, switch to absolute mode */
 482                       {
 483                           /*
 484                            * Absolute Mode
 485                            */
 486                           length = escape_code;
 487                           while(length--)
 488                             {
 489                                 color_index = (*pIn++);
 490                                 XPutPixel(bmpImage, x++, line,
 491                                           colors[color_index]);
 492                             }
 493
 494                           /*
 495                            * If you think for a moment you'll realise that the
 496                            * only time we could ever possibly read an odd
 497                            * number of bytes is when there is a 0x00 (escape),
 498                            * a value >0x02 (absolute mode) and then an odd-
 499                            * length run.  Therefore this is the only place we
 500                            * need to worry about it.  Everywhere else the
 501                            * bytes are always read in pairs.  [JAY]
 502                            */
 503                           if (escape_code & 1)
 504                             pIn++; /* Throw away the pad byte. */
 505                           break;
 506                       }
 507                   } /* switch (escape_code) : Escape sequence */
 508             }  /* process either an encoded sequence or an escape sequence */
 509
 510           /* We expect to come here more than once per line. */
 511       } while (line >= 0);  /* Do this until the bitmap is filled */
 512
 513     /*
 514      * Everybody comes here at the end.
 515      * Check how we exited the loop and print a message if it's a bit odd.
 516      *                                          [JAY]
 517      */
 518     if ( (*(pIn-2) != 0/*escape*/) || (*(pIn-1)!= RleEnd) )
 519       {
 520         dprintf_bitmap(stddeb, "DIB_SetImageBits_RLE8(): End-of-bitmap "
 521                        "without (strictly) proper escape code.  Last two "
 522                        "bytes were: %02X %02X.\n",
 523                        (int)*(pIn-2),
 524                        (int)*(pIn-1));
 525       }
 526 }
 527
 528
 529 /***********************************************************************
 530  *           DIB_SetImageBits_24
 531  *
 532  * SetDIBits for a 24-bit deep DIB.
 533  */
 534 static void DIB_SetImageBits_24( DWORD lines, BYTE *bits, DWORD width,
 535                                  DC *dc, XImage *bmpImage )
 536 {
 537     DWORD x;
 538     BYTE pad = (4 - ((width*3) & 3)) & 3;
 539
 540     /* "bits" order is reversed for some reason */
 541
 542     while (lines--)
 543     {
 544         for (x = 0; x < width; x++, bits += 3)
 545             XPutPixel( bmpImage, x, lines,
 546                        COLOR_ToPhysical(dc, RGB(bits[2],bits[1],bits[0])) );
 547
 548         bits += pad;
 549     }
 550 }
 551
 552
 553 /***********************************************************************
 554  *           DIB_SetImageBits
 555  *
 556  * Transfer the bits to an X image.
 557  * Helper function for SetDIBits() and SetDIBitsToDevice().
 558  */
 559 static int DIB_SetImageBits( DC *dc, DWORD lines, WORD depth, LPSTR bits,
 560                              DWORD infoWidth, WORD infoBpp,
 561                              BITMAPINFO *info, WORD coloruse,
 562                              Drawable drawable, GC gc, int xSrc, int ySrc,
 563                              int xDest, int yDest, int width, int height )
 564 {
 565     int *colorMapping;
 566     XImage *bmpImage;
 567     DWORD compression = 0;
 568
 569     if (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 570         compression = info->bmiHeader.biCompression;
 571
 572       /* Build the color mapping table */
 573
 574     if (infoBpp == 24) colorMapping = NULL;
 575     else
 576         if (!(colorMapping = DIB_BuildColorMap( dc, coloruse, depth, info )))
 577             return 0;
 578
 579     if( dc->w.flags & DC_DIRTY ) CLIPPING_UpdateGCRegion(dc);
 580
 581       /* Transfer the pixels */
 582     XCREATEIMAGE(bmpImage, infoWidth, lines, depth );
 583
 584     switch(infoBpp)
 585     {
 586     case 1:
 587         DIB_SetImageBits_1( lines, bits, infoWidth,
 588                             colorMapping, bmpImage );
 589         break;
 590     case 4:
 591         if (compression) DIB_SetImageBits_RLE4( lines, bits, infoWidth,
 592                                                 colorMapping, bmpImage );
 593         else DIB_SetImageBits_4( lines, bits, infoWidth,
 594                                  colorMapping, bmpImage );
 595         break;
 596     case 8:
 597         if (compression) DIB_SetImageBits_RLE8( lines, bits, infoWidth,
 598                                                 colorMapping, bmpImage );
 599         else DIB_SetImageBits_8( lines, bits, infoWidth,
 600                                  colorMapping, bmpImage );
 601         break;
 602     case 24:
 603         DIB_SetImageBits_24( lines, bits, infoWidth, dc, bmpImage );
 604         break;
 605     default:
 606         fprintf( stderr, "Invalid depth %d for SetDIBits!\n", infoBpp );
 607         break;
 608     }
 609     if (colorMapping) free(colorMapping);
 610     XPutImage( display, drawable, gc, bmpImage, xSrc, ySrc,
 611                xDest, yDest, width, height );
 612     XDestroyImage( bmpImage );
 613     return lines;
 614 }
 615
 616
 617 /***********************************************************************
 618  *           StretchDIBits16   (GDI.439)
 619  */
 620 INT16 StretchDIBits16( HDC16 hdc, INT16 xDst, INT16 yDst, INT16 widthDst,
 621                        INT16 heightDst, INT16 xSrc, INT16 ySrc, INT16 widthSrc,
 622                        INT16 heightSrc, const VOID *bits,
 623                        const BITMAPINFO *info, UINT16 wUsage, DWORD dwRop )
 624 {
 625     return (INT16)StretchDIBits32( hdc, xDst, yDst, widthDst, heightDst,
 626                                    xSrc, ySrc, widthSrc, heightSrc, bits,
 627                                    info, wUsage, dwRop );
 628 }
 629
 630
 631 /***********************************************************************
 632  *           StretchDIBits32   (GDI32.351)
 633  */
 634 INT32 StretchDIBits32( HDC32 hdc, INT32 xDst, INT32 yDst, INT32 widthDst,
 635                        INT32 heightDst, INT32 xSrc, INT32 ySrc, INT32 widthSrc,
 636                        INT32 heightSrc, const void *bits,
 637                        const BITMAPINFO *info, UINT32 wUsage, DWORD dwRop )
 638 {
 639     HBITMAP32 hBitmap, hOldBitmap;
 640     HDC32 hdcMem;
 641
 642     hBitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
 643                                 bits, info, wUsage );
 644     hdcMem = CreateCompatibleDC32( hdc );
 645     hOldBitmap = SelectObject32( hdcMem, hBitmap );
 646     StretchBlt32( hdc, xDst, yDst, widthDst, heightDst,
 647                   hdcMem, xSrc, ySrc, widthSrc, heightSrc, dwRop );
 648     SelectObject32( hdcMem, hOldBitmap );
 649     DeleteDC32( hdcMem );
 650     DeleteObject32( hBitmap );
 651     return heightSrc;
 652 }
 653
 654
 655 /***********************************************************************
 656  *           SetDIBits16    (GDI.440)
 657  */
 658 INT16 SetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
 659                    UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
 660                    UINT16 coloruse )
 661 {
 662     return SetDIBits32( hdc, hbitmap, startscan, lines, bits, info, coloruse );
 663 }
 664
 665
 666 /***********************************************************************
 667  *           SetDIBits32   (GDI32.312)
 668  */
 669 INT32 SetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
 670                    UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
 671                    UINT32 coloruse )
 672 {
 673     DC * dc;
 674     BITMAPOBJ * bmp;
 675     DWORD width, height;
 676     WORD bpp;
 677
 678       /* Check parameters */
 679
 680     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 681     if (!dc)
 682     {
 683         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 684         if (!dc) return 0;
 685     }
 686     if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
 687         return 0;
 688     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &bpp ) == -1)
 689         return 0;
 690     if (!lines || (startscan >= (WORD)height)) return 0;
 691     if (startscan + lines > height) lines = height - startscan;
 692
 693     return CallTo32_LargeStack( (int(*)())DIB_SetImageBits, 16,
 694                                 dc, lines, bmp->bitmap.bmBitsPixel,
 695                                 bits, width, bpp, info,
 696                                 coloruse, bmp->pixmap, BITMAP_GC(bmp), 0, 0, 0,
 697                                 height - startscan - lines,
 698                                 bmp->bitmap.bmWidth, lines );
 699 }
 700
 701
 702 /***********************************************************************
 703  *           SetDIBitsToDevice16    (GDI.443)
 704  */
 705 INT16 SetDIBitsToDevice16( HDC16 hdc, INT16 xDest, INT16 yDest, INT16 cx,
 706                            INT16 cy, INT16 xSrc, INT16 ySrc, UINT16 startscan,
 707                            UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
 708                            UINT16 coloruse )
 709 {
 710     return SetDIBitsToDevice32( hdc, xDest, yDest, cx, cy, xSrc, ySrc,
 711                                 startscan, lines, bits, info, coloruse );
 712 }
 713
 714
 715 /***********************************************************************
 716  *           SetDIBitsToDevice32   (GDI32.313)
 717  */
 718 INT32 SetDIBitsToDevice32( HDC32 hdc, INT32 xDest, INT32 yDest, DWORD cx,
 719                            DWORD cy, INT32 xSrc, INT32 ySrc, UINT32 startscan,
 720                            UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
 721                            UINT32 coloruse )
 722 {
 723     DC * dc;
 724     DWORD width, height;
 725     WORD bpp;
 726
 727       /* Check parameters */
 728
 729     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 730     if (!dc)
 731     {
 732         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 733         if (!dc) return 0;
 734     }
 735     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &bpp ) == -1)
 736         return 0;
 737     if (!lines || (startscan >= height)) return 0;
 738     if (startscan + lines > height) lines = height - startscan;
 739     if (ySrc < startscan) ySrc = startscan;
 740     else if (ySrc >= startscan + lines) return 0;
 741     if (xSrc >= width) return 0;
 742     if (ySrc + cy >= startscan + lines) cy = startscan + lines - ySrc;
 743     if (xSrc + cx >= width) cx = width - xSrc;
 744     if (!cx || !cy) return 0;
 745
 746     DC_SetupGCForText( dc );  /* To have the correct colors */
 747     XSetFunction( display, dc->u.x.gc, DC_XROPfunction[dc->w.ROPmode-1] );
 748     return CallTo32_LargeStack( (int(*)())DIB_SetImageBits, 16,
 749                                 dc, lines, dc->w.bitsPerPixel, bits, width,
 750                                 bpp, info, coloruse,
 751                                 dc->u.x.drawable, dc->u.x.gc,
 752                                 xSrc, ySrc - startscan,
 753                                 dc->w.DCOrgX + XLPTODP( dc, xDest ),
 754                                 dc->w.DCOrgY + YLPTODP( dc, yDest ),
 755                                 cx, cy );
 756 }
 757
 758
 759
 760 /***********************************************************************
 761  *           GetDIBits16    (GDI.441)
 762  */
 763 INT16 GetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
 764                    UINT16 lines, LPSTR bits, BITMAPINFO * info,
 765                    UINT16 coloruse )
 766 {
 767     return GetDIBits32( hdc, hbitmap, startscan, lines, bits, info, coloruse );
 768 }
 769
 770
 771 /***********************************************************************
 772  *           GetDIBits32    (GDI32.170)
 773  */
 774 INT32 GetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
 775                    UINT32 lines, LPSTR bits, BITMAPINFO * info,
 776                    UINT32 coloruse )
 777 {
 778     DC * dc;
 779     BITMAPOBJ * bmp;
 780     PALETTEENTRY * palEntry;
 781     PALETTEOBJ * palette;
 782     XImage * bmpImage, * dibImage;
 783     int i, x, y;
 784
 785     if (!lines) return 0;
 786     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 787     if (!dc)
 788     {
 789         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 790         if (!dc) return 0;
 791     }
 792     if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
 793         return 0;
 794     if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
 795         return 0;
 796
 797       /* Transfer color info */
 798
 799     palEntry = palette->logpalette.palPalEntry;
 800     for (i = 0; i < info->bmiHeader.biClrUsed; i++, palEntry++)
 801     {
 802         if (coloruse == DIB_RGB_COLORS)
 803         {
 804             info->bmiColors[i].rgbRed      = palEntry->peRed;
 805             info->bmiColors[i].rgbGreen    = palEntry->peGreen;
 806             info->bmiColors[i].rgbBlue     = palEntry->peBlue;
 807             info->bmiColors[i].rgbReserved = 0;
 808         }
 809         else ((WORD *)info->bmiColors)[i] = (WORD)i;
 810     }
 811
 812       /* Transfer the pixels (very slow...) */
 813
 814     if (bits)
 815     {
 816         bmpImage = (XImage *)CallTo32_LargeStack( (int (*)())XGetImage, 8,
 817                                display, bmp->pixmap, 0, 0, bmp->bitmap.bmWidth,
 818                                bmp->bitmap.bmHeight, AllPlanes, ZPixmap );
 819         dibImage = DIB_DIBmpToImage( &info->bmiHeader, bits );
 820
 821         for (y = 0; y < lines; y++)
 822         {
 823             for (x = 0; x < info->bmiHeader.biWidth; x++)
 824             {
 825                 XPutPixel( dibImage, x, y,
 826                   XGetPixel(bmpImage, x, bmp->bitmap.bmHeight-startscan-y-1) );
 827
 828             }
 829         }
 830
 831         dibImage->data = NULL;
 832         XDestroyImage( dibImage );
 833         XDestroyImage( bmpImage );
 834     }
 835     info->bmiHeader.biCompression = 0;
 836     return lines;
 837 }
 838
 839
 840 /***********************************************************************
 841  *           CreateDIBitmap16    (GDI.442)
 842  */
 843 HBITMAP16 CreateDIBitmap16( HDC16 hdc, const BITMAPINFOHEADER * header,
 844                             DWORD init, LPCVOID bits, const BITMAPINFO * data,
 845                             UINT16 coloruse )
 846 {
 847     return CreateDIBitmap32( hdc, header, init, bits, data, coloruse );
 848 }
 849
 850
 851 /***********************************************************************
 852  *           CreateDIBitmap32    (GDI32.37)
 853  */
 854 HBITMAP32 CreateDIBitmap32( HDC32 hdc, const BITMAPINFOHEADER *header,
 855                             DWORD init, LPCVOID bits, const BITMAPINFO *data,
 856                             UINT32 coloruse )
 857 {
 858     HBITMAP32 handle;
 859     BOOL32 fColor;
 860     DWORD width, height;
 861     WORD bpp;
 862
 863     if (DIB_GetBitmapInfo( header, &width, &height, &bpp ) == -1) return 0;
 864
 865     /* Check if we should create a monochrome or color bitmap. */
 866     /* We create a monochrome bitmap only if it has exactly 2  */
 867     /* colors, which are either black or white, nothing else.  */
 868     /* In all other cases, we create a color bitmap.           */
 869
 870     if (bpp != 1) fColor = TRUE;
 871     else if ((coloruse != DIB_RGB_COLORS) ||
 872              (init != CBM_INIT) || !data) fColor = FALSE;
 873     else
 874     {
 875         if (data->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 876         {
 877             RGBQUAD *rgb = data->bmiColors;
 878             DWORD col = RGB( rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue );
 879             if ((col == RGB(0,0,0)) || (col == RGB(0xff,0xff,0xff)))
 880             {
 881                 rgb++;
 882                 col = RGB( rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue );
 883                 fColor = ((col != RGB(0,0,0)) && (col != RGB(0xff,0xff,0xff)));
 884             }
 885             else fColor = TRUE;
 886         }
 887         else if (data->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 888         {
 889             RGBTRIPLE *rgb = ((BITMAPCOREINFO *)data)->bmciColors;
 890             DWORD col = RGB( rgb->rgbtRed, rgb->rgbtGreen, rgb->rgbtBlue );
 891             if ((col == RGB(0,0,0)) || (col == RGB(0xff,0xff,0xff)))
 892             {
 893                 rgb++;
 894                 col = RGB( rgb->rgbtRed, rgb->rgbtGreen, rgb->rgbtBlue );
 895                 fColor = ((col != RGB(0,0,0)) && (col != RGB(0xff,0xff,0xff)));
 896             }
 897             else fColor = TRUE;
 898         }
 899         else
 900         {
 901             fprintf( stderr, "CreateDIBitmap: wrong size (%ld) for data\n",
 902                      data->bmiHeader.biSize );
 903             return 0;
 904         }
 905     }
 906
 907     /* Now create the bitmap */
 908
 909     handle = fColor ? CreateCompatibleBitmap32( hdc, width, height ) :
 910                       CreateBitmap32( width, height, 1, 1, NULL );
 911     if (!handle) return 0;
 912
 913     if (init == CBM_INIT)
 914         SetDIBits32( hdc, handle, 0, height, bits, data, coloruse );
 915     return handle;
 916 }