dlls/gdi32/dibdrv/graphics.c

   1 /*
   2  * DIB driver graphics operations.
   3  *
   4  * Copyright 2011 Huw Davies
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <assert.h>
  22 #include "gdi_private.h"
  23 #include "dibdrv.h"
  24
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(dib);
  28
  29 static RECT get_device_rect( HDC hdc, int left, int top, int right, int bottom, BOOL rtl_correction )
  30 {
  31     RECT rect;
  32
  33     rect.left   = left;
  34     rect.top    = top;
  35     rect.right  = right;
  36     rect.bottom = bottom;
  37     if (rtl_correction && GetLayout( hdc ) & LAYOUT_RTL)
  38     {
  39         /* shift the rectangle so that the right border is included after mirroring */
  40         /* it would be more correct to do this after LPtoDP but that's not what Windows does */
  41         rect.left--;
  42         rect.right--;
  43     }
  44     LPtoDP( hdc, (POINT *)&rect, 2 );
  45     if (rect.left > rect.right)
  46     {
  47         int tmp = rect.left;
  48         rect.left = rect.right;
  49         rect.right = tmp;
  50     }
  51     if (rect.top > rect.bottom)
  52     {
  53         int tmp = rect.top;
  54         rect.top = rect.bottom;
  55         rect.bottom = tmp;
  56     }
  57     return rect;
  58 }
  59
  60 /* Intensities of the 17 glyph levels when drawn with text component of 0xff on a
  61    black bkgnd.  [A log-log plot of these data gives: y = 77.05 * x^0.4315]. */
  62 static const BYTE ramp[17] =
  63 {
  64     0,    0x4d, 0x68, 0x7c,
  65     0x8c, 0x9a, 0xa7, 0xb2,
  66     0xbd, 0xc7, 0xd0, 0xd9,
  67     0xe1, 0xe9, 0xf0, 0xf8,
  68     0xff
  69 };
  70
  71 /* For a give text-color component and a glyph level, calculate the
  72    range of dst intensities, the min/max corresponding to 0/0xff bkgnd
  73    components respectively.
  74
  75    The minimum is a linear interpolation between 0 and the value in
  76    the ramp table.
  77
  78    The maximum is a linear interpolation between the value from the
  79    ramp table read in reverse and 0xff.
  80
  81    To find the resulting pixel intensity, we note that if the text and
  82    bkgnd intensities are the same then the result must be that
  83    intensity.  Otherwise we linearly interpolate between either the
  84    min or the max value and this intermediate value depending on which
  85    side of the inequality we lie.
  86 */
  87
  88 static inline void get_range( BYTE aa, DWORD text_comp, BYTE *min_comp, BYTE *max_comp )
  89 {
  90     *min_comp = (ramp[aa] * text_comp) / 0xff;
  91     *max_comp = ramp[16 - aa] + ((0xff - ramp[16 - aa]) * text_comp) / 0xff;
  92 }
  93
  94 static inline void get_aa_ranges( COLORREF col, struct intensity_range intensities[17] )
  95 {
  96     int i;
  97
  98     for (i = 0; i < 17; i++)
  99     {
 100         get_range( i, GetRValue(col), &intensities[i].r_min, &intensities[i].r_max );
 101         get_range( i, GetGValue(col), &intensities[i].g_min, &intensities[i].g_max );
 102         get_range( i, GetBValue(col), &intensities[i].b_min, &intensities[i].b_max );
 103     }
 104 }
 105
 106 /**********************************************************************
 107  *                 get_text_bkgnd_masks
 108  *
 109  * See the comment above get_pen_bkgnd_masks
 110  */
 111 static inline void get_text_bkgnd_masks( dibdrv_physdev *pdev, rop_mask *mask )
 112 {
 113     COLORREF bg = GetBkColor( pdev->dev.hdc );
 114
 115     mask->and = 0;
 116
 117     if (pdev->dib.bit_count != 1)
 118         mask->xor = get_pixel_color( pdev, bg, FALSE );
 119     else
 120     {
 121         COLORREF fg = GetTextColor( pdev->dev.hdc );
 122         mask->xor = get_pixel_color( pdev, fg, TRUE );
 123         if (fg != bg) mask->xor = ~mask->xor;
 124     }
 125 }
 126
 127 static void draw_glyph( dibdrv_physdev *pdev, const POINT *origin, const GLYPHMETRICS *metrics,
 128                         const struct gdi_image_bits *image, DWORD text_color,
 129                         const struct intensity_range *ranges, const struct clipped_rects *clipped_rects )
 130 {
 131     int i;
 132     RECT rect, clipped_rect;
 133     POINT src_origin;
 134     dib_info glyph_dib;
 135
 136     glyph_dib.bit_count = 8;
 137     glyph_dib.width     = metrics->gmBlackBoxX;
 138     glyph_dib.height    = metrics->gmBlackBoxY;
 139     glyph_dib.stride    = get_dib_stride( metrics->gmBlackBoxX, 8 );
 140     glyph_dib.bits      = *image;
 141
 142     rect.left   = origin->x  + metrics->gmptGlyphOrigin.x;
 143     rect.top    = origin->y  - metrics->gmptGlyphOrigin.y;
 144     rect.right  = rect.left  + metrics->gmBlackBoxX;
 145     rect.bottom = rect.top   + metrics->gmBlackBoxY;
 146
 147     for (i = 0; i < clipped_rects->count; i++)
 148     {
 149         if (intersect_rect( &clipped_rect, &rect, clipped_rects->rects + i ))
 150         {
 151             src_origin.x = clipped_rect.left - rect.left;
 152             src_origin.y = clipped_rect.top  - rect.top;
 153
 154             pdev->dib.funcs->draw_glyph( &pdev->dib, &clipped_rect, &glyph_dib, &src_origin,
 155                                          text_color, ranges );
 156         }
 157     }
 158 }
 159
 160 static const BYTE masks[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
 161 static const int padding[4] = {0, 3, 2, 1};
 162
 163 /***********************************************************************
 164  *         get_glyph_bitmap
 165  *
 166  * Retrieve a 17-level bitmap for the appropiate glyph.
 167  *
 168  * For non-antialiased bitmaps convert them to the 17-level format
 169  * using only values 0 or 16.
 170  */
 171 static DWORD get_glyph_bitmap( HDC hdc, UINT index, UINT aa_flags, GLYPHMETRICS *metrics,
 172                                struct gdi_image_bits *image )
 173 {
 174     UINT ggo_flags = aa_flags | GGO_GLYPH_INDEX;
 175     static const MAT2 identity = { {0,1}, {0,0}, {0,0}, {0,1} };
 176     UINT indices[3] = {0, 0, 0x20};
 177     int i, x, y;
 178     DWORD ret, size;
 179     BYTE *buf, *dst, *src;
 180     int pad, stride;
 181
 182     image->ptr = NULL;
 183     image->is_copy = FALSE;
 184     image->free = free_heap_bits;
 185     image->param = NULL;
 186
 187     indices[0] = index;
 188
 189     for (i = 0; i < sizeof(indices) / sizeof(indices[0]); i++)
 190     {
 191         index = indices[i];
 192         ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, 0, NULL, &identity );
 193         if (ret != GDI_ERROR) break;
 194     }
 195
 196     if (ret == GDI_ERROR) return ERROR_NOT_FOUND;
 197     if (!ret) return ERROR_SUCCESS; /* empty glyph */
 198
 199     /* We'll convert non-antialiased 1-bpp bitmaps to 8-bpp, so these sizes relate to 8-bpp */
 200     pad = padding[ metrics->gmBlackBoxX % 4 ];
 201     stride = get_dib_stride( metrics->gmBlackBoxX, 8 );
 202     size = metrics->gmBlackBoxY * stride;
 203
 204     buf = HeapAlloc( GetProcessHeap(), 0, size );
 205     if (!buf) return ERROR_OUTOFMEMORY;
 206
 207     ret = GetGlyphOutlineW( hdc, index, ggo_flags, metrics, size, buf, &identity );
 208     if (ret == GDI_ERROR)
 209     {
 210         HeapFree( GetProcessHeap(), 0, buf );
 211         return ERROR_NOT_FOUND;
 212     }
 213
 214     if (aa_flags == GGO_BITMAP)
 215     {
 216         for (y = metrics->gmBlackBoxY - 1; y >= 0; y--)
 217         {
 218             src = buf + y * get_dib_stride( metrics->gmBlackBoxX, 1 );
 219             dst = buf + y * stride;
 220
 221             if (pad) memset( dst + metrics->gmBlackBoxX, 0, pad );
 222
 223             for (x = metrics->gmBlackBoxX - 1; x >= 0; x--)
 224                 dst[x] = (src[x / 8] & masks[x % 8]) ? 0x10 : 0;
 225         }
 226     }
 227     else if (pad)
 228     {
 229         for (y = 0, dst = buf; y < metrics->gmBlackBoxY; y++, dst += stride)
 230             memset( dst + metrics->gmBlackBoxX, 0, pad );
 231     }
 232
 233     image->ptr = buf;
 234     return ERROR_SUCCESS;
 235 }
 236
 237 BOOL render_aa_text_bitmapinfo( HDC hdc, BITMAPINFO *info, struct gdi_image_bits *bits,
 238                                 struct bitblt_coords *src, INT x, INT y, UINT flags,
 239                                 UINT aa_flags, LPCWSTR str, UINT count, const INT *dx )
 240 {
 241     dib_info dib;
 242     UINT i;
 243     DWORD err;
 244     BOOL got_pixel;
 245     COLORREF fg, bg;
 246     DWORD fg_pixel, bg_pixel;
 247     struct intensity_range glyph_intensities[17];
 248
 249     assert( info->bmiHeader.biBitCount > 8 ); /* mono and indexed formats don't support anti-aliasing */
 250
 251     init_dib_info_from_bitmapinfo( &dib, info, bits->ptr, 0 );
 252
 253     fg = make_rgb_colorref( hdc, &dib, GetTextColor( hdc ), &got_pixel, &fg_pixel);
 254     if (!got_pixel) fg_pixel = dib.funcs->colorref_to_pixel( &dib, fg );
 255
 256     get_aa_ranges( fg, glyph_intensities );
 257
 258     if (flags & ETO_OPAQUE)
 259     {
 260         rop_mask bkgnd_color;
 261
 262         bg = make_rgb_colorref( hdc, &dib, GetBkColor( hdc ), &got_pixel, &bg_pixel);
 263         if (!got_pixel) bg_pixel = dib.funcs->colorref_to_pixel( &dib, bg );
 264
 265         bkgnd_color.and = 0;
 266         bkgnd_color.xor = bg_pixel;
 267         dib.funcs->solid_rects( &dib, 1, &src->visrect, bkgnd_color.and, bkgnd_color.xor );
 268     }
 269
 270     for (i = 0; i < count; i++)
 271     {
 272         GLYPHMETRICS metrics;
 273         struct gdi_image_bits image;
 274
 275         err = get_glyph_bitmap( hdc, (UINT)str[i], aa_flags, &metrics, &image );
 276         if (err) continue;
 277
 278         if (image.ptr)
 279         {
 280             RECT rect, clipped_rect;
 281             POINT src_origin;
 282             dib_info glyph_dib;
 283
 284             glyph_dib.bit_count = 8;
 285             glyph_dib.width     = metrics.gmBlackBoxX;
 286             glyph_dib.height    = metrics.gmBlackBoxY;
 287             glyph_dib.stride    = get_dib_stride( metrics.gmBlackBoxX, 8 );
 288             glyph_dib.bits      = image;
 289
 290             rect.left   = x + metrics.gmptGlyphOrigin.x;
 291             rect.top    = y - metrics.gmptGlyphOrigin.y;
 292             rect.right  = rect.left + metrics.gmBlackBoxX;
 293             rect.bottom = rect.top  + metrics.gmBlackBoxY;
 294
 295             if (intersect_rect( &clipped_rect, &rect, &src->visrect ))
 296             {
 297                 src_origin.x = clipped_rect.left - rect.left;
 298                 src_origin.y = clipped_rect.top  - rect.top;
 299
 300                 dib.funcs->draw_glyph( &dib, &clipped_rect, &glyph_dib, &src_origin,
 301                                        fg_pixel, glyph_intensities );
 302             }
 303         }
 304         if (image.free) image.free( &image );
 305
 306         if (dx)
 307         {
 308             if (flags & ETO_PDY)
 309             {
 310                 x += dx[ i * 2 ];
 311                 y += dx[ i * 2 + 1];
 312             }
 313             else
 314                 x += dx[ i ];
 315         }
 316         else
 317         {
 318             x += metrics.gmCellIncX;
 319             y += metrics.gmCellIncY;
 320         }
 321     }
 322     return TRUE;
 323 }
 324
 325 /***********************************************************************
 326  *           dibdrv_ExtTextOut
 327  */
 328 BOOL dibdrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags,
 329                         const RECT *rect, LPCWSTR str, UINT count, const INT *dx )
 330 {
 331     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 332     struct clipped_rects clipped_rects;
 333     UINT aa_flags, i;
 334     POINT origin;
 335     DWORD text_color, err;
 336     struct intensity_range ranges[17];
 337
 338     init_clipped_rects( &clipped_rects );
 339
 340     if (flags & ETO_OPAQUE)
 341     {
 342         rop_mask bkgnd_color;
 343         get_text_bkgnd_masks( pdev, &bkgnd_color );
 344         get_clipped_rects( &pdev->dib, rect, pdev->clip, &clipped_rects );
 345         pdev->dib.funcs->solid_rects( &pdev->dib, clipped_rects.count, clipped_rects.rects,
 346                                       bkgnd_color.and, bkgnd_color.xor );
 347     }
 348
 349     if (count == 0) goto done;
 350
 351     if (flags & ETO_CLIPPED)
 352     {
 353         if (!(flags & ETO_OPAQUE))  /* otherwise we have done it already */
 354             get_clipped_rects( &pdev->dib, rect, pdev->clip, &clipped_rects );
 355     }
 356     else
 357     {
 358         free_clipped_rects( &clipped_rects );
 359         get_clipped_rects( &pdev->dib, NULL, pdev->clip, &clipped_rects );
 360     }
 361     if (!clipped_rects.count) return TRUE;
 362
 363     text_color = get_pixel_color( pdev, GetTextColor( pdev->dev.hdc ), TRUE );
 364     get_aa_ranges( pdev->dib.funcs->pixel_to_colorref( &pdev->dib, text_color ), ranges );
 365
 366     aa_flags = get_font_aa_flags( dev->hdc );
 367     origin.x = x;
 368     origin.y = y;
 369     for (i = 0; i < count; i++)
 370     {
 371         GLYPHMETRICS metrics;
 372         struct gdi_image_bits image;
 373
 374         err = get_glyph_bitmap( dev->hdc, (UINT)str[i], aa_flags, &metrics, &image );
 375         if (err) continue;
 376
 377         if (image.ptr) draw_glyph( pdev, &origin, &metrics, &image, text_color, ranges, &clipped_rects );
 378         if (image.free) image.free( &image );
 379
 380         if (dx)
 381         {
 382             if (flags & ETO_PDY)
 383             {
 384                 origin.x += dx[ i * 2 ];
 385                 origin.y += dx[ i * 2 + 1];
 386             }
 387             else
 388                 origin.x += dx[ i ];
 389         }
 390         else
 391         {
 392             origin.x += metrics.gmCellIncX;
 393             origin.y += metrics.gmCellIncY;
 394         }
 395     }
 396
 397 done:
 398     free_clipped_rects( &clipped_rects );
 399     return TRUE;
 400 }
 401
 402 /***********************************************************************
 403  *           dibdrv_GetNearestColor
 404  */
 405 COLORREF dibdrv_GetNearestColor( PHYSDEV dev, COLORREF color )
 406 {
 407     dibdrv_physdev *pdev = get_dibdrv_pdev( dev );
 408     DWORD pixel;
 409
 410     TRACE( "(%p, %08x)\n", dev, color );
 411
 412     pixel = get_pixel_color( pdev, color, FALSE );
 413     return pdev->dib.funcs->pixel_to_colorref( &pdev->dib, pixel );
 414 }
 415
 416 /***********************************************************************
 417  *           dibdrv_GetPixel
 418  */
 419 COLORREF dibdrv_GetPixel( PHYSDEV dev, INT x, INT y )
 420 {
 421     dibdrv_physdev *pdev = get_dibdrv_pdev( dev );
 422     POINT pt;
 423     DWORD pixel;
 424
 425     TRACE( "(%p, %d, %d)\n", dev, x, y );
 426
 427     pt.x = x;
 428     pt.y = y;
 429     LPtoDP( dev->hdc, &pt, 1 );
 430
 431     if (pt.x < 0 || pt.x >= pdev->dib.width ||
 432         pt.y < 0 || pt.y >= pdev->dib.height)
 433         return CLR_INVALID;
 434
 435     pixel = pdev->dib.funcs->get_pixel( &pdev->dib, &pt );
 436     return pdev->dib.funcs->pixel_to_colorref( &pdev->dib, pixel );
 437 }
 438
 439 /***********************************************************************
 440  *           dibdrv_LineTo
 441  */
 442 BOOL dibdrv_LineTo( PHYSDEV dev, INT x, INT y )
 443 {
 444     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pLineTo );
 445     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 446     POINT pts[2];
 447     HRGN region = 0;
 448     BOOL ret;
 449
 450     if(defer_pen(pdev)) return next->funcs->pLineTo( next, x, y );
 451
 452     GetCurrentPositionEx(dev->hdc, pts);
 453     pts[1].x = x;
 454     pts[1].y = y;
 455
 456     LPtoDP(dev->hdc, pts, 2);
 457
 458     if (pdev->pen_uses_region && !(region = CreateRectRgn( 0, 0, 0, 0 ))) return FALSE;
 459
 460     reset_dash_origin(pdev);
 461
 462     ret = pdev->pen_lines(pdev, 2, pts, FALSE, region);
 463
 464     if (region)
 465     {
 466         if (pdev->clip) CombineRgn( region, region, pdev->clip, RGN_AND );
 467         ret = pen_rect( pdev, NULL, region, GetROP2(dev->hdc) );
 468         DeleteObject( region );
 469     }
 470     return ret;
 471 }
 472
 473 /***********************************************************************
 474  *           get_rop2_from_rop
 475  *
 476  * Returns the binary rop that is equivalent to the provided ternary rop
 477  * if the src bits are ignored.
 478  */
 479 static inline INT get_rop2_from_rop(INT rop)
 480 {
 481     return (((rop >> 18) & 0x0c) | ((rop >> 16) & 0x03)) + 1;
 482 }
 483
 484 /***********************************************************************
 485  *           dibdrv_PatBlt
 486  */
 487 BOOL dibdrv_PatBlt( PHYSDEV dev, struct bitblt_coords *dst, DWORD rop )
 488 {
 489     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 490
 491     TRACE("(%p, %d, %d, %d, %d, %06x)\n", dev, dst->x, dst->y, dst->width, dst->height, rop);
 492
 493     return brush_rect( pdev, &dst->visrect, pdev->clip, get_rop2_from_rop(rop) );
 494 }
 495
 496 /***********************************************************************
 497  *           dibdrv_PaintRgn
 498  */
 499 BOOL dibdrv_PaintRgn( PHYSDEV dev, HRGN rgn )
 500 {
 501     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 502     const WINEREGION *region;
 503     int i;
 504     RECT rect;
 505
 506     TRACE("%p, %p\n", dev, rgn);
 507
 508     region = get_wine_region( rgn );
 509     if(!region) return FALSE;
 510
 511     for(i = 0; i < region->numRects; i++)
 512     {
 513         rect = get_device_rect( dev->hdc, region->rects[i].left, region->rects[i].top,
 514                                 region->rects[i].right, region->rects[i].bottom, FALSE );
 515         brush_rect( pdev, &rect, pdev->clip, GetROP2( dev->hdc ) );
 516     }
 517
 518     release_wine_region( rgn );
 519     return TRUE;
 520 }
 521
 522 /***********************************************************************
 523  *           dibdrv_PolyPolygon
 524  */
 525 BOOL dibdrv_PolyPolygon( PHYSDEV dev, const POINT *pt, const INT *counts, DWORD polygons )
 526 {
 527     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 528     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pPolyPolygon );
 529     DWORD total, i, pos;
 530     BOOL ret = FALSE;
 531     POINT *points;
 532     INT rop = GetROP2( dev->hdc );
 533     HRGN outline = 0, interior;
 534
 535     if (defer_pen( pdev )) return next->funcs->pPolyPolygon( next, pt, counts, polygons );
 536
 537     for (i = total = 0; i < polygons; i++)
 538     {
 539         if (counts[i] < 2) return FALSE;
 540         total += counts[i];
 541     }
 542
 543     points = HeapAlloc( GetProcessHeap(), 0, total * sizeof(*pt) );
 544     if (!points) return FALSE;
 545     memcpy( points, pt, total * sizeof(*pt) );
 546     LPtoDP( dev->hdc, points, total );
 547
 548     if (!(interior = CreatePolyPolygonRgn( points, counts, polygons, GetPolyFillMode( dev->hdc ))))
 549     {
 550         HeapFree( GetProcessHeap(), 0, points );
 551         return FALSE;
 552     }
 553
 554     if (pdev->clip) CombineRgn( interior, interior, pdev->clip, RGN_AND );
 555
 556     /* if not using a region, paint the interior first so the outline can overlap it */
 557     if (!pdev->pen_uses_region || !(outline = CreateRectRgn( 0, 0, 0, 0 )))
 558         ret = brush_rect( pdev, NULL, interior, rop );
 559
 560     for (i = pos = 0; i < polygons; i++)
 561     {
 562         reset_dash_origin( pdev );
 563         pdev->pen_lines( pdev, counts[i], points + pos, TRUE, outline );
 564         pos += counts[i];
 565     }
 566
 567     if (outline)
 568     {
 569         if (pdev->clip) CombineRgn( outline, outline, pdev->clip, RGN_AND );
 570         CombineRgn( interior, interior, outline, RGN_DIFF );
 571         ret = pen_rect( pdev, NULL, outline, rop ) && brush_rect( pdev, NULL, interior, rop );
 572         DeleteObject( outline );
 573     }
 574
 575     DeleteObject( interior );
 576     HeapFree( GetProcessHeap(), 0, points );
 577     return ret;
 578 }
 579
 580 /***********************************************************************
 581  *           dibdrv_PolyPolyline
 582  */
 583 BOOL dibdrv_PolyPolyline( PHYSDEV dev, const POINT* pt, const DWORD* counts, DWORD polylines )
 584 {
 585     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 586     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pPolyPolyline );
 587     DWORD max_points = 0, i;
 588     POINT *points;
 589     BOOL ret = TRUE;
 590     INT rop = GetROP2( dev->hdc );
 591     HRGN outline = 0;
 592
 593     if (defer_pen( pdev )) return next->funcs->pPolyPolyline( next, pt, counts, polylines );
 594
 595     for (i = 0; i < polylines; i++)
 596     {
 597         if (counts[i] < 2) return FALSE;
 598         max_points = max( counts[i], max_points );
 599     }
 600
 601     points = HeapAlloc( GetProcessHeap(), 0, max_points * sizeof(*pt) );
 602     if (!points) return FALSE;
 603
 604     if (pdev->pen_uses_region && !(outline = CreateRectRgn( 0, 0, 0, 0 )))
 605     {
 606         HeapFree( GetProcessHeap(), 0, points );
 607         return FALSE;
 608     }
 609
 610     for (i = 0; i < polylines; i++)
 611     {
 612         memcpy( points, pt, counts[i] * sizeof(*pt) );
 613         pt += counts[i];
 614         LPtoDP( dev->hdc, points, counts[i] );
 615
 616         reset_dash_origin( pdev );
 617         pdev->pen_lines( pdev, counts[i], points, FALSE, outline );
 618     }
 619
 620     if (outline)
 621     {
 622         if (pdev->clip) CombineRgn( outline, outline, pdev->clip, RGN_AND );
 623         ret = pen_rect( pdev, NULL, outline, rop );
 624         DeleteObject( outline );
 625     }
 626
 627     HeapFree( GetProcessHeap(), 0, points );
 628     return ret;
 629 }
 630
 631 /***********************************************************************
 632  *           dibdrv_Polygon
 633  */
 634 BOOL dibdrv_Polygon( PHYSDEV dev, const POINT *pt, INT count )
 635 {
 636     INT counts[1] = { count };
 637
 638     return dibdrv_PolyPolygon( dev, pt, counts, 1 );
 639 }
 640
 641 /***********************************************************************
 642  *           dibdrv_Polyline
 643  */
 644 BOOL dibdrv_Polyline( PHYSDEV dev, const POINT* pt, INT count )
 645 {
 646     DWORD counts[1] = { count };
 647
 648     if (count < 0) return FALSE;
 649     return dibdrv_PolyPolyline( dev, pt, counts, 1 );
 650 }
 651
 652 /***********************************************************************
 653  *           dibdrv_Rectangle
 654  */
 655 BOOL dibdrv_Rectangle( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
 656 {
 657     PHYSDEV next = GET_NEXT_PHYSDEV( dev, pRectangle );
 658     dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
 659     RECT rect = get_device_rect( dev->hdc, left, top, right, bottom, TRUE );
 660     POINT pts[4];
 661     BOOL ret;
 662     INT rop = GetROP2( dev->hdc );
 663     HRGN outline = 0;
 664
 665     TRACE("(%p, %d, %d, %d, %d)\n", dev, left, top, right, bottom);
 666
 667     if(rect.left == rect.right || rect.top == rect.bottom) return TRUE;
 668
 669     if(defer_pen(pdev))
 670         return next->funcs->pRectangle( next, left, top, right, bottom );
 671
 672     if (pdev->pen_style == PS_INSIDEFRAME)
 673     {
 674         rect.left   += pdev->pen_width / 2;
 675         rect.top    += pdev->pen_width / 2;
 676         rect.right  -= (pdev->pen_width - 1) / 2;
 677         rect.bottom -= (pdev->pen_width - 1) / 2;
 678     }
 679
 680     if (pdev->pen_uses_region && !(outline = CreateRectRgn( 0, 0, 0, 0 ))) return FALSE;
 681
 682     rect.right--;
 683     rect.bottom--;
 684     reset_dash_origin(pdev);
 685
 686     /* 4 pts going anti-clockwise starting from top-right */
 687     pts[0].x = pts[3].x = rect.right;
 688     pts[0].y = pts[1].y = rect.top;
 689     pts[1].x = pts[2].x = rect.left;
 690     pts[2].y = pts[3].y = rect.bottom;
 691
 692     pdev->pen_lines(pdev, 4, pts, TRUE, outline);
 693
 694     if (outline)
 695     {
 696         HRGN interior = CreateRectRgnIndirect( &rect );
 697
 698         CombineRgn( interior, interior, outline, RGN_DIFF );
 699         if (pdev->clip)
 700         {
 701             CombineRgn( outline, outline, pdev->clip, RGN_AND );
 702             CombineRgn( interior, interior, pdev->clip, RGN_AND );
 703         }
 704         ret = pen_rect( pdev, NULL, outline, rop ) && brush_rect( pdev, NULL, interior, rop );
 705         DeleteObject( outline );
 706         DeleteObject( interior );
 707     }
 708     else
 709     {
 710         rect.left   += (pdev->pen_width + 1) / 2;
 711         rect.top    += (pdev->pen_width + 1) / 2;
 712         rect.right  -= pdev->pen_width / 2;
 713         rect.bottom -= pdev->pen_width / 2;
 714         ret = brush_rect( pdev, &rect, pdev->clip, rop );
 715     }
 716     return ret;
 717 }
 718
 719 /***********************************************************************
 720  *           dibdrv_SetPixel
 721  */
 722 COLORREF dibdrv_SetPixel( PHYSDEV dev, INT x, INT y, COLORREF color )
 723 {
 724     dibdrv_physdev *pdev = get_dibdrv_pdev( dev );
 725     struct clipped_rects clipped_rects;
 726     RECT rect;
 727     POINT pt;
 728     DWORD pixel;
 729
 730     TRACE( "(%p, %d, %d, %08x)\n", dev, x, y, color );
 731
 732     pt.x = x;
 733     pt.y = y;
 734     LPtoDP( dev->hdc, &pt, 1 );
 735     rect.left = pt.x;
 736     rect.top =  pt.y;
 737     rect.right = rect.left + 1;
 738     rect.bottom = rect.top + 1;
 739
 740     /* SetPixel doesn't do the 1bpp massaging like other fg colors */
 741     pixel = get_pixel_color( pdev, color, FALSE );
 742     color = pdev->dib.funcs->pixel_to_colorref( &pdev->dib, pixel );
 743
 744     if (!get_clipped_rects( &pdev->dib, &rect, pdev->clip, &clipped_rects )) return color;
 745     pdev->dib.funcs->solid_rects( &pdev->dib, clipped_rects.count, clipped_rects.rects, 0, pixel );
 746     free_clipped_rects( &clipped_rects );
 747     return color;
 748 }