dlls/gdi32/painting.c

   1 /*
   2  * GDI drawing functions.
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  * Copyright 1997 Bertho A. Stultiens
   6  *           1999 Huw D M Davies
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winerror.h"
  34 #include "gdi_private.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(gdi);
  38
  39
  40 /***********************************************************************
  41  *           null driver fallback implementations
  42  */
  43
  44 BOOL nulldrv_AngleArc( PHYSDEV dev, INT x, INT y, DWORD radius, FLOAT start, FLOAT sweep )
  45 {
  46     INT x1 = GDI_ROUND( x + cos( start * M_PI / 180 ) * radius );
  47     INT y1 = GDI_ROUND( y - sin( start * M_PI / 180 ) * radius );
  48     INT x2 = GDI_ROUND( x + cos( (start + sweep) * M_PI / 180) * radius );
  49     INT y2 = GDI_ROUND( y - sin( (start + sweep) * M_PI / 180) * radius );
  50     INT arcdir = SetArcDirection( dev->hdc, sweep >= 0 ? AD_COUNTERCLOCKWISE : AD_CLOCKWISE );
  51     BOOL ret = ArcTo( dev->hdc, x - radius, y - radius, x + radius, y + radius, x1, y1, x2, y2 );
  52     SetArcDirection( dev->hdc, arcdir );
  53     return ret;
  54 }
  55
  56 BOOL nulldrv_ArcTo( PHYSDEV dev, INT left, INT top, INT right, INT bottom,
  57                     INT xstart, INT ystart, INT xend, INT yend )
  58 {
  59     INT width = abs( right - left );
  60     INT height = abs( bottom - top );
  61     double xradius = width / 2.0;
  62     double yradius = height / 2.0;
  63     double xcenter = right > left ? left + xradius : right + xradius;
  64     double ycenter = bottom > top ? top + yradius : bottom + yradius;
  65     double angle;
  66
  67     if (!height || !width) return FALSE;
  68     /* draw a line from the current position to the starting point of the arc, then draw the arc */
  69     angle = atan2( (ystart - ycenter) / height, (xstart - xcenter) / width );
  70     LineTo( dev->hdc, GDI_ROUND( xcenter + cos(angle) * xradius ),
  71             GDI_ROUND( ycenter + sin(angle) * yradius ));
  72     return Arc( dev->hdc, left, top, right, bottom, xstart, ystart, xend, yend );
  73 }
  74
  75 BOOL nulldrv_FillRgn( PHYSDEV dev, HRGN rgn, HBRUSH brush )
  76 {
  77     BOOL ret = FALSE;
  78     HBRUSH prev;
  79
  80     if ((prev = SelectObject( dev->hdc, brush )))
  81     {
  82         ret = PaintRgn( dev->hdc, rgn );
  83         SelectObject( dev->hdc, prev );
  84     }
  85     return ret;
  86 }
  87
  88 BOOL nulldrv_FrameRgn( PHYSDEV dev, HRGN rgn, HBRUSH brush, INT width, INT height )
  89 {
  90     BOOL ret = FALSE;
  91     HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
  92
  93     if (tmp)
  94     {
  95         if (REGION_FrameRgn( tmp, rgn, width, height )) ret = FillRgn( dev->hdc, tmp, brush );
  96         DeleteObject( tmp );
  97     }
  98     return ret;
  99 }
 100
 101 BOOL nulldrv_InvertRgn( PHYSDEV dev, HRGN rgn )
 102 {
 103     HBRUSH prev_brush = SelectObject( dev->hdc, GetStockObject(BLACK_BRUSH) );
 104     INT prev_rop = SetROP2( dev->hdc, R2_NOT );
 105     BOOL ret = PaintRgn( dev->hdc, rgn );
 106     SelectObject( dev->hdc, prev_brush );
 107     SetROP2( dev->hdc, prev_rop );
 108     return ret;
 109 }
 110
 111 BOOL nulldrv_PolyBezier( PHYSDEV dev, const POINT *points, DWORD count )
 112 {
 113     BOOL ret = FALSE;
 114     POINT *pts;
 115     INT n;
 116
 117     if ((pts = GDI_Bezier( points, count, &n )))
 118     {
 119         ret = Polyline( dev->hdc, pts, n );
 120         HeapFree( GetProcessHeap(), 0, pts );
 121     }
 122     return ret;
 123 }
 124
 125 BOOL nulldrv_PolyBezierTo( PHYSDEV dev, const POINT *points, DWORD count )
 126 {
 127     DC *dc = get_nulldrv_dc( dev );
 128     BOOL ret = FALSE;
 129     POINT *pts = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT) * (count + 1) );
 130
 131     if (pts)
 132     {
 133         pts[0] = dc->cur_pos;
 134         memcpy( pts + 1, points, sizeof(POINT) * count );
 135         ret = PolyBezier( dev->hdc, pts, count + 1 );
 136         HeapFree( GetProcessHeap(), 0, pts );
 137     }
 138     return ret;
 139 }
 140
 141 BOOL nulldrv_PolyDraw( PHYSDEV dev, const POINT *points, const BYTE *types, DWORD count )
 142 {
 143     DC *dc = get_nulldrv_dc( dev );
 144     POINT *line_pts = NULL, *bzr_pts = NULL, bzr[4];
 145     DWORD i;
 146     INT num_pts, num_bzr_pts, space, size;
 147
 148     /* check for valid point types */
 149     for (i = 0; i < count; i++)
 150     {
 151         switch (types[i])
 152         {
 153         case PT_MOVETO:
 154         case PT_LINETO | PT_CLOSEFIGURE:
 155         case PT_LINETO:
 156             break;
 157         case PT_BEZIERTO:
 158             if (i + 2 >= count) return FALSE;
 159             if (types[i + 1] != PT_BEZIERTO) return FALSE;
 160             if ((types[i + 2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO) return FALSE;
 161             i += 2;
 162             break;
 163         default:
 164             return FALSE;
 165         }
 166     }
 167
 168     space = count + 300;
 169     line_pts = HeapAlloc( GetProcessHeap(), 0, space * sizeof(POINT) );
 170     num_pts = 1;
 171
 172     line_pts[0] = dc->cur_pos;
 173     for (i = 0; i < count; i++)
 174     {
 175         switch (types[i])
 176         {
 177         case PT_MOVETO:
 178             if (num_pts >= 2) Polyline( dev->hdc, line_pts, num_pts );
 179             num_pts = 0;
 180             line_pts[num_pts++] = points[i];
 181             break;
 182         case PT_LINETO:
 183         case (PT_LINETO | PT_CLOSEFIGURE):
 184             line_pts[num_pts++] = points[i];
 185             break;
 186         case PT_BEZIERTO:
 187             bzr[0].x = line_pts[num_pts - 1].x;
 188             bzr[0].y = line_pts[num_pts - 1].y;
 189             memcpy( &bzr[1], &points[i], 3 * sizeof(POINT) );
 190
 191             if ((bzr_pts = GDI_Bezier( bzr, 4, &num_bzr_pts )))
 192             {
 193                 size = num_pts + (count - i) + num_bzr_pts;
 194                 if (space < size)
 195                 {
 196                     space = size * 2;
 197                     line_pts = HeapReAlloc( GetProcessHeap(), 0, line_pts, space * sizeof(POINT) );
 198                 }
 199                 memcpy( &line_pts[num_pts], &bzr_pts[1], (num_bzr_pts - 1) * sizeof(POINT) );
 200                 num_pts += num_bzr_pts - 1;
 201                 HeapFree( GetProcessHeap(), 0, bzr_pts );
 202             }
 203             i += 2;
 204             break;
 205         }
 206         if (types[i] & PT_CLOSEFIGURE) line_pts[num_pts++] = line_pts[0];
 207     }
 208
 209     if (num_pts >= 2) Polyline( dev->hdc, line_pts, num_pts );
 210     HeapFree( GetProcessHeap(), 0, line_pts );
 211     return TRUE;
 212 }
 213
 214 BOOL nulldrv_PolylineTo( PHYSDEV dev, const POINT *points, INT count )
 215 {
 216     DC *dc = get_nulldrv_dc( dev );
 217     BOOL ret = FALSE;
 218     POINT *pts;
 219
 220     if (!count) return FALSE;
 221     if ((pts = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT) * (count + 1) )))
 222     {
 223         pts[0] = dc->cur_pos;
 224         memcpy( pts + 1, points, sizeof(POINT) * count );
 225         ret = Polyline( dev->hdc, pts, count + 1 );
 226         HeapFree( GetProcessHeap(), 0, pts );
 227     }
 228     return ret;
 229 }
 230
 231 /***********************************************************************
 232  *           LineTo    (GDI32.@)
 233  */
 234 BOOL WINAPI LineTo( HDC hdc, INT x, INT y )
 235 {
 236     DC * dc = get_dc_ptr( hdc );
 237     PHYSDEV physdev;
 238     BOOL ret;
 239
 240     if(!dc) return FALSE;
 241
 242     update_dc( dc );
 243     physdev = GET_DC_PHYSDEV( dc, pLineTo );
 244     ret = physdev->funcs->pLineTo( physdev, x, y );
 245
 246     if(ret)
 247     {
 248         dc->cur_pos.x = x;
 249         dc->cur_pos.y = y;
 250     }
 251     release_dc_ptr( dc );
 252     return ret;
 253 }
 254
 255
 256 /***********************************************************************
 257  *           MoveToEx    (GDI32.@)
 258  */
 259 BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, LPPOINT pt )
 260 {
 261     BOOL ret;
 262     PHYSDEV physdev;
 263     DC * dc = get_dc_ptr( hdc );
 264
 265     if(!dc) return FALSE;
 266
 267     if(pt)
 268         *pt = dc->cur_pos;
 269
 270     dc->cur_pos.x = x;
 271     dc->cur_pos.y = y;
 272
 273     physdev = GET_DC_PHYSDEV( dc, pMoveTo );
 274     ret = physdev->funcs->pMoveTo( physdev, x, y );
 275     release_dc_ptr( dc );
 276     return ret;
 277 }
 278
 279
 280 /***********************************************************************
 281  *           Arc    (GDI32.@)
 282  */
 283 BOOL WINAPI Arc( HDC hdc, INT left, INT top, INT right,
 284                      INT bottom, INT xstart, INT ystart,
 285                      INT xend, INT yend )
 286 {
 287     PHYSDEV physdev;
 288     BOOL ret;
 289     DC * dc = get_dc_ptr( hdc );
 290
 291     if (!dc) return FALSE;
 292     update_dc( dc );
 293     physdev = GET_DC_PHYSDEV( dc, pArc );
 294     ret = physdev->funcs->pArc( physdev, left, top, right, bottom, xstart, ystart, xend, yend );
 295     release_dc_ptr( dc );
 296     return ret;
 297 }
 298
 299 /***********************************************************************
 300  *           ArcTo    (GDI32.@)
 301  */
 302 BOOL WINAPI ArcTo( HDC hdc,
 303                      INT left,   INT top,
 304                      INT right,  INT bottom,
 305                      INT xstart, INT ystart,
 306                      INT xend,   INT yend )
 307 {
 308     double width = abs( right - left ),
 309         height = abs( bottom - top ),
 310         xradius = width/2,
 311         yradius = height/2,
 312         xcenter = right > left ? left+xradius : right+xradius,
 313         ycenter = bottom > top ? top+yradius : bottom+yradius,
 314         angle;
 315     PHYSDEV physdev;
 316     BOOL result;
 317     DC * dc = get_dc_ptr( hdc );
 318     if(!dc) return FALSE;
 319
 320     update_dc( dc );
 321     physdev = GET_DC_PHYSDEV( dc, pArcTo );
 322     result = physdev->funcs->pArcTo( physdev, left, top, right, bottom, xstart, ystart, xend, yend );
 323
 324     if (result)
 325     {
 326         angle = atan2(((yend-ycenter)/height),
 327                       ((xend-xcenter)/width));
 328         dc->cur_pos.x = GDI_ROUND( xcenter + (cos( angle ) * xradius) );
 329         dc->cur_pos.y = GDI_ROUND( ycenter + (sin( angle ) * yradius) );
 330     }
 331     release_dc_ptr( dc );
 332     return result;
 333 }
 334
 335
 336 /***********************************************************************
 337  *           Pie   (GDI32.@)
 338  */
 339 BOOL WINAPI Pie( HDC hdc, INT left, INT top,
 340                      INT right, INT bottom, INT xstart, INT ystart,
 341                      INT xend, INT yend )
 342 {
 343     BOOL ret;
 344     PHYSDEV physdev;
 345     DC * dc = get_dc_ptr( hdc );
 346     if (!dc) return FALSE;
 347
 348     update_dc( dc );
 349     physdev = GET_DC_PHYSDEV( dc, pPie );
 350     ret = physdev->funcs->pPie( physdev, left, top, right, bottom, xstart, ystart, xend, yend );
 351     release_dc_ptr( dc );
 352     return ret;
 353 }
 354
 355
 356 /***********************************************************************
 357  *           Chord    (GDI32.@)
 358  */
 359 BOOL WINAPI Chord( HDC hdc, INT left, INT top,
 360                        INT right, INT bottom, INT xstart, INT ystart,
 361                        INT xend, INT yend )
 362 {
 363     BOOL ret;
 364     PHYSDEV physdev;
 365     DC * dc = get_dc_ptr( hdc );
 366     if (!dc) return FALSE;
 367
 368     update_dc( dc );
 369     physdev = GET_DC_PHYSDEV( dc, pChord );
 370     ret = physdev->funcs->pChord( physdev, left, top, right, bottom, xstart, ystart, xend, yend );
 371     release_dc_ptr( dc );
 372     return ret;
 373 }
 374
 375
 376 /***********************************************************************
 377  *           Ellipse    (GDI32.@)
 378  */
 379 BOOL WINAPI Ellipse( HDC hdc, INT left, INT top,
 380                          INT right, INT bottom )
 381 {
 382     BOOL ret;
 383     PHYSDEV physdev;
 384     DC * dc = get_dc_ptr( hdc );
 385     if (!dc) return FALSE;
 386
 387     update_dc( dc );
 388     physdev = GET_DC_PHYSDEV( dc, pEllipse );
 389     ret = physdev->funcs->pEllipse( physdev, left, top, right, bottom );
 390     release_dc_ptr( dc );
 391     return ret;
 392 }
 393
 394
 395 /***********************************************************************
 396  *           Rectangle    (GDI32.@)
 397  */
 398 BOOL WINAPI Rectangle( HDC hdc, INT left, INT top,
 399                            INT right, INT bottom )
 400 {
 401     PHYSDEV physdev;
 402     BOOL ret;
 403     DC * dc = get_dc_ptr( hdc );
 404
 405     if (!dc) return FALSE;
 406     update_dc( dc );
 407     physdev = GET_DC_PHYSDEV( dc, pRectangle );
 408     ret = physdev->funcs->pRectangle( physdev, left, top, right, bottom );
 409     release_dc_ptr( dc );
 410     return ret;
 411 }
 412
 413
 414 /***********************************************************************
 415  *           RoundRect    (GDI32.@)
 416  */
 417 BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right,
 418                            INT bottom, INT ell_width, INT ell_height )
 419 {
 420     PHYSDEV physdev;
 421     BOOL ret;
 422     DC *dc = get_dc_ptr( hdc );
 423
 424     if (!dc) return FALSE;
 425     update_dc( dc );
 426     physdev = GET_DC_PHYSDEV( dc, pRoundRect );
 427     ret = physdev->funcs->pRoundRect( physdev, left, top, right, bottom, ell_width, ell_height );
 428     release_dc_ptr( dc );
 429     return ret;
 430 }
 431
 432 /***********************************************************************
 433  *           SetPixel    (GDI32.@)
 434  */
 435 COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
 436 {
 437     PHYSDEV physdev;
 438     COLORREF ret;
 439     DC * dc = get_dc_ptr( hdc );
 440
 441     if (!dc) return 0;
 442     update_dc( dc );
 443     physdev = GET_DC_PHYSDEV( dc, pSetPixel );
 444     ret = physdev->funcs->pSetPixel( physdev, x, y, color );
 445     release_dc_ptr( dc );
 446     return ret;
 447 }
 448
 449 /***********************************************************************
 450  *           SetPixelV    (GDI32.@)
 451  */
 452 BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color )
 453 {
 454     PHYSDEV physdev;
 455     DC * dc = get_dc_ptr( hdc );
 456
 457     if (!dc) return FALSE;
 458     update_dc( dc );
 459     physdev = GET_DC_PHYSDEV( dc, pSetPixel );
 460     physdev->funcs->pSetPixel( physdev, x, y, color );
 461     release_dc_ptr( dc );
 462     return TRUE;
 463 }
 464
 465 /***********************************************************************
 466  *           GetPixel    (GDI32.@)
 467  */
 468 COLORREF WINAPI GetPixel( HDC hdc, INT x, INT y )
 469 {
 470     PHYSDEV physdev;
 471     COLORREF ret;
 472     DC * dc = get_dc_ptr( hdc );
 473
 474     if (!dc) return CLR_INVALID;
 475     update_dc( dc );
 476     physdev = GET_DC_PHYSDEV( dc, pGetPixel );
 477     ret = physdev->funcs->pGetPixel( physdev, x, y );
 478     release_dc_ptr( dc );
 479     return ret;
 480 }
 481
 482
 483 /******************************************************************************
 484  * GdiSetPixelFormat [GDI32.@]
 485  *
 486  * Probably not the correct semantics, it's supposed to be an internal backend for SetPixelFormat.
 487  */
 488 BOOL WINAPI GdiSetPixelFormat( HDC hdc, INT format, const PIXELFORMATDESCRIPTOR *descr )
 489 {
 490     DC *dc;
 491     BOOL ret = TRUE;
 492
 493     TRACE("(%p,%d,%p)\n", hdc, format, descr);
 494
 495     if (!(dc = get_dc_ptr( hdc ))) return FALSE;
 496
 497     if (!dc->pixel_format) dc->pixel_format = format;
 498     else ret = (dc->pixel_format == format);
 499     release_dc_ptr( dc );
 500     return ret;
 501 }
 502
 503
 504 /******************************************************************************
 505  * GdiDescribePixelFormat [GDI32.@]
 506  *
 507  * Probably not the correct semantics, it's supposed to be an internal backend for DescribePixelFormat.
 508  */
 509 INT WINAPI GdiDescribePixelFormat( HDC hdc, INT format, UINT size, PIXELFORMATDESCRIPTOR *descr )
 510 {
 511     FIXME( "(%p,%d,%d,%p): stub\n", hdc, format, size, descr );
 512     return 0;
 513 }
 514
 515
 516 /******************************************************************************
 517  * GdiSwapBuffers [GDI32.@]
 518  *
 519  * Probably not the correct semantics, it's supposed to be an internal backend for SwapBuffers.
 520  */
 521 BOOL WINAPI GdiSwapBuffers( HDC hdc )
 522 {
 523     FIXME( "(%p): stub\n", hdc );
 524     return FALSE;
 525 }
 526
 527
 528 /***********************************************************************
 529  *           PaintRgn    (GDI32.@)
 530  */
 531 BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
 532 {
 533     PHYSDEV physdev;
 534     BOOL ret;
 535     DC * dc = get_dc_ptr( hdc );
 536
 537     if (!dc) return FALSE;
 538     update_dc( dc );
 539     physdev = GET_DC_PHYSDEV( dc, pPaintRgn );
 540     ret = physdev->funcs->pPaintRgn( physdev, hrgn );
 541     release_dc_ptr( dc );
 542     return ret;
 543 }
 544
 545
 546 /***********************************************************************
 547  *           FillRgn    (GDI32.@)
 548  */
 549 BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
 550 {
 551     PHYSDEV physdev;
 552     BOOL retval;
 553     DC * dc = get_dc_ptr( hdc );
 554
 555     if (!dc) return FALSE;
 556     update_dc( dc );
 557     physdev = GET_DC_PHYSDEV( dc, pFillRgn );
 558     retval = physdev->funcs->pFillRgn( physdev, hrgn, hbrush );
 559     release_dc_ptr( dc );
 560     return retval;
 561 }
 562
 563
 564 /***********************************************************************
 565  *           FrameRgn     (GDI32.@)
 566  */
 567 BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush,
 568                           INT nWidth, INT nHeight )
 569 {
 570     PHYSDEV physdev;
 571     BOOL ret;
 572     DC *dc = get_dc_ptr( hdc );
 573
 574     if (!dc) return FALSE;
 575     update_dc( dc );
 576     physdev = GET_DC_PHYSDEV( dc, pFrameRgn );
 577     ret = physdev->funcs->pFrameRgn( physdev, hrgn, hbrush, nWidth, nHeight );
 578     release_dc_ptr( dc );
 579     return ret;
 580 }
 581
 582
 583 /***********************************************************************
 584  *           InvertRgn    (GDI32.@)
 585  */
 586 BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
 587 {
 588     PHYSDEV physdev;
 589     BOOL ret;
 590     DC *dc = get_dc_ptr( hdc );
 591
 592     if (!dc) return FALSE;
 593     update_dc( dc );
 594     physdev = GET_DC_PHYSDEV( dc, pInvertRgn );
 595     ret = physdev->funcs->pInvertRgn( physdev, hrgn );
 596     release_dc_ptr( dc );
 597     return ret;
 598 }
 599
 600
 601 /**********************************************************************
 602  *          Polyline   (GDI32.@)
 603  */
 604 BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count )
 605 {
 606     PHYSDEV physdev;
 607     BOOL ret;
 608     DC * dc = get_dc_ptr( hdc );
 609
 610     if (!dc) return FALSE;
 611     update_dc( dc );
 612     physdev = GET_DC_PHYSDEV( dc, pPolyline );
 613     ret = physdev->funcs->pPolyline( physdev, pt, count );
 614     release_dc_ptr( dc );
 615     return ret;
 616 }
 617
 618 /**********************************************************************
 619  *          PolylineTo   (GDI32.@)
 620  */
 621 BOOL WINAPI PolylineTo( HDC hdc, const POINT* pt, DWORD cCount )
 622 {
 623     DC * dc = get_dc_ptr( hdc );
 624     PHYSDEV physdev;
 625     BOOL ret;
 626
 627     if(!dc) return FALSE;
 628
 629     update_dc( dc );
 630     physdev = GET_DC_PHYSDEV( dc, pPolylineTo );
 631     ret = physdev->funcs->pPolylineTo( physdev, pt, cCount );
 632
 633     if (ret && cCount)
 634         dc->cur_pos = pt[cCount - 1];
 635
 636     release_dc_ptr( dc );
 637     return ret;
 638 }
 639
 640
 641 /**********************************************************************
 642  *          Polygon  (GDI32.@)
 643  */
 644 BOOL WINAPI Polygon( HDC hdc, const POINT* pt, INT count )
 645 {
 646     PHYSDEV physdev;
 647     BOOL ret;
 648     DC * dc = get_dc_ptr( hdc );
 649
 650     if (!dc) return FALSE;
 651     update_dc( dc );
 652     physdev = GET_DC_PHYSDEV( dc, pPolygon );
 653     ret = physdev->funcs->pPolygon( physdev, pt, count );
 654     release_dc_ptr( dc );
 655     return ret;
 656 }
 657
 658
 659 /**********************************************************************
 660  *          PolyPolygon  (GDI32.@)
 661  */
 662 BOOL WINAPI PolyPolygon( HDC hdc, const POINT* pt, const INT* counts,
 663                              UINT polygons )
 664 {
 665     PHYSDEV physdev;
 666     BOOL ret;
 667     DC * dc = get_dc_ptr( hdc );
 668
 669     if (!dc) return FALSE;
 670     update_dc( dc );
 671     physdev = GET_DC_PHYSDEV( dc, pPolyPolygon );
 672     ret = physdev->funcs->pPolyPolygon( physdev, pt, counts, polygons );
 673     release_dc_ptr( dc );
 674     return ret;
 675 }
 676
 677 /**********************************************************************
 678  *          PolyPolyline  (GDI32.@)
 679  */
 680 BOOL WINAPI PolyPolyline( HDC hdc, const POINT* pt, const DWORD* counts,
 681                             DWORD polylines )
 682 {
 683     PHYSDEV physdev;
 684     BOOL ret;
 685     DC * dc = get_dc_ptr( hdc );
 686
 687     if (!dc) return FALSE;
 688     update_dc( dc );
 689     physdev = GET_DC_PHYSDEV( dc, pPolyPolyline );
 690     ret = physdev->funcs->pPolyPolyline( physdev, pt, counts, polylines );
 691     release_dc_ptr( dc );
 692     return ret;
 693 }
 694
 695 /**********************************************************************
 696  *          ExtFloodFill   (GDI32.@)
 697  */
 698 BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color,
 699                               UINT fillType )
 700 {
 701     PHYSDEV physdev;
 702     BOOL ret;
 703     DC * dc = get_dc_ptr( hdc );
 704
 705     if (!dc) return FALSE;
 706     update_dc( dc );
 707     physdev = GET_DC_PHYSDEV( dc, pExtFloodFill );
 708     ret = physdev->funcs->pExtFloodFill( physdev, x, y, color, fillType );
 709     release_dc_ptr( dc );
 710     return ret;
 711 }
 712
 713
 714 /**********************************************************************
 715  *          FloodFill   (GDI32.@)
 716  */
 717 BOOL WINAPI FloodFill( HDC hdc, INT x, INT y, COLORREF color )
 718 {
 719     return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER );
 720 }
 721
 722
 723 /******************************************************************************
 724  * PolyBezier [GDI32.@]
 725  * Draws one or more Bezier curves
 726  *
 727  * PARAMS
 728  *    hDc     [I] Handle to device context
 729  *    lppt    [I] Pointer to endpoints and control points
 730  *    cPoints [I] Count of endpoints and control points
 731  *
 732  * RETURNS
 733  *    Success: TRUE
 734  *    Failure: FALSE
 735  */
 736 BOOL WINAPI PolyBezier( HDC hdc, const POINT* lppt, DWORD cPoints )
 737 {
 738     PHYSDEV physdev;
 739     BOOL ret;
 740     DC * dc;
 741
 742     /* cPoints must be 3 * n + 1 (where n>=1) */
 743     if (cPoints == 1 || (cPoints % 3) != 1) return FALSE;
 744
 745     dc = get_dc_ptr( hdc );
 746     if(!dc) return FALSE;
 747
 748     update_dc( dc );
 749     physdev = GET_DC_PHYSDEV( dc, pPolyBezier );
 750     ret = physdev->funcs->pPolyBezier( physdev, lppt, cPoints );
 751     release_dc_ptr( dc );
 752     return ret;
 753 }
 754
 755 /******************************************************************************
 756  * PolyBezierTo [GDI32.@]
 757  * Draws one or more Bezier curves
 758  *
 759  * PARAMS
 760  *    hDc     [I] Handle to device context
 761  *    lppt    [I] Pointer to endpoints and control points
 762  *    cPoints [I] Count of endpoints and control points
 763  *
 764  * RETURNS
 765  *    Success: TRUE
 766  *    Failure: FALSE
 767  */
 768 BOOL WINAPI PolyBezierTo( HDC hdc, const POINT* lppt, DWORD cPoints )
 769 {
 770     DC * dc;
 771     BOOL ret;
 772     PHYSDEV physdev;
 773
 774     /* cbPoints must be 3 * n (where n>=1) */
 775     if (!cPoints || (cPoints % 3) != 0) return FALSE;
 776
 777     dc = get_dc_ptr( hdc );
 778     if(!dc) return FALSE;
 779
 780     update_dc( dc );
 781     physdev = GET_DC_PHYSDEV( dc, pPolyBezierTo );
 782     ret = physdev->funcs->pPolyBezierTo( physdev, lppt, cPoints );
 783
 784     if(ret)
 785         dc->cur_pos = lppt[cPoints - 1];
 786
 787     release_dc_ptr( dc );
 788     return ret;
 789 }
 790
 791 /***********************************************************************
 792  *      AngleArc (GDI32.@)
 793  */
 794 BOOL WINAPI AngleArc(HDC hdc, INT x, INT y, DWORD dwRadius, FLOAT eStartAngle, FLOAT eSweepAngle)
 795 {
 796     PHYSDEV physdev;
 797     BOOL result;
 798     DC *dc;
 799
 800     if( (signed int)dwRadius < 0 )
 801         return FALSE;
 802
 803     dc = get_dc_ptr( hdc );
 804     if(!dc) return FALSE;
 805
 806     update_dc( dc );
 807     physdev = GET_DC_PHYSDEV( dc, pAngleArc );
 808     result = physdev->funcs->pAngleArc( physdev, x, y, dwRadius, eStartAngle, eSweepAngle );
 809
 810     if (result)
 811     {
 812         dc->cur_pos.x = GDI_ROUND( x + cos( (eStartAngle + eSweepAngle) * M_PI / 180 ) * dwRadius );
 813         dc->cur_pos.y = GDI_ROUND( y - sin( (eStartAngle + eSweepAngle) * M_PI / 180 ) * dwRadius );
 814     }
 815     release_dc_ptr( dc );
 816     return result;
 817 }
 818
 819 /***********************************************************************
 820  *      PolyDraw (GDI32.@)
 821  */
 822 BOOL WINAPI PolyDraw(HDC hdc, const POINT *lppt, const BYTE *lpbTypes,
 823                        DWORD cCount)
 824 {
 825     DC *dc = get_dc_ptr( hdc );
 826     PHYSDEV physdev;
 827     BOOL result;
 828
 829     if(!dc) return FALSE;
 830
 831     update_dc( dc );
 832     physdev = GET_DC_PHYSDEV( dc, pPolyDraw );
 833     result = physdev->funcs->pPolyDraw( physdev, lppt, lpbTypes, cCount );
 834     if (result && cCount)
 835         dc->cur_pos = lppt[cCount - 1];
 836
 837     release_dc_ptr( dc );
 838     return result;
 839 }
 840
 841
 842 /**********************************************************************
 843  *           LineDDA   (GDI32.@)
 844  */
 845 BOOL WINAPI LineDDA(INT nXStart, INT nYStart, INT nXEnd, INT nYEnd,
 846                     LINEDDAPROC callback, LPARAM lParam )
 847 {
 848     INT xadd = 1, yadd = 1;
 849     INT err,erradd;
 850     INT cnt;
 851     INT dx = nXEnd - nXStart;
 852     INT dy = nYEnd - nYStart;
 853
 854     if (dx < 0)
 855     {
 856         dx = -dx;
 857         xadd = -1;
 858     }
 859     if (dy < 0)
 860     {
 861         dy = -dy;
 862         yadd = -1;
 863     }
 864     if (dx > dy)  /* line is "more horizontal" */
 865     {
 866         err = 2*dy - dx; erradd = 2*dy - 2*dx;
 867         for(cnt = 0;cnt < dx; cnt++)
 868         {
 869             callback(nXStart,nYStart,lParam);
 870             if (err > 0)
 871             {
 872                 nYStart += yadd;
 873                 err += erradd;
 874             }
 875             else err += 2*dy;
 876             nXStart += xadd;
 877         }
 878     }
 879     else   /* line is "more vertical" */
 880     {
 881         err = 2*dx - dy; erradd = 2*dx - 2*dy;
 882         for(cnt = 0;cnt < dy; cnt++)
 883         {
 884             callback(nXStart,nYStart,lParam);
 885             if (err > 0)
 886             {
 887                 nXStart += xadd;
 888                 err += erradd;
 889             }
 890             else err += 2*dx;
 891             nYStart += yadd;
 892         }
 893     }
 894     return TRUE;
 895 }
 896
 897
 898 /******************************************************************
 899  *
 900  *   *Very* simple bezier drawing code,
 901  *
 902  *   It uses a recursive algorithm to divide the curve in a series
 903  *   of straight line segments. Not ideal but sufficient for me.
 904  *   If you are in need for something better look for some incremental
 905  *   algorithm.
 906  *
 907  *   7 July 1998 Rein Klazes
 908  */
 909
 910  /*
 911   * some macro definitions for bezier drawing
 912   *
 913   * to avoid truncation errors the coordinates are
 914   * shifted upwards. When used in drawing they are
 915   * shifted down again, including correct rounding
 916   * and avoiding floating point arithmetic
 917   * 4 bits should allow 27 bits coordinates which I saw
 918   * somewhere in the win32 doc's
 919   *
 920   */
 921
 922 #define BEZIERSHIFTBITS 4
 923 #define BEZIERSHIFTUP(x)    ((x)<<BEZIERSHIFTBITS)
 924 #define BEZIERPIXEL        BEZIERSHIFTUP(1)
 925 #define BEZIERSHIFTDOWN(x)  (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
 926 /* maximum depth of recursion */
 927 #define BEZIERMAXDEPTH  8
 928
 929 /* size of array to store points on */
 930 /* enough for one curve */
 931 #define BEZIER_INITBUFSIZE    (150)
 932
 933 /* calculate Bezier average, in this case the middle
 934  * correctly rounded...
 935  * */
 936
 937 #define BEZIERMIDDLE(Mid, P1, P2) \
 938     (Mid).x=((P1).x+(P2).x + 1)/2;\
 939     (Mid).y=((P1).y+(P2).y + 1)/2;
 940
 941 /**********************************************************
 942 * BezierCheck helper function to check
 943 * that recursion can be terminated
 944 *       Points[0] and Points[3] are begin and endpoint
 945 *       Points[1] and Points[2] are control points
 946 *       level is the recursion depth
 947 *       returns true if the recursion can be terminated
 948 */
 949 static BOOL BezierCheck( int level, POINT *Points)
 950 {
 951     INT dx, dy;
 952     dx=Points[3].x-Points[0].x;
 953     dy=Points[3].y-Points[0].y;
 954     if(abs(dy)<=abs(dx)){/* shallow line */
 955         /* check that control points are between begin and end */
 956         if(Points[1].x < Points[0].x){
 957             if(Points[1].x < Points[3].x)
 958                 return FALSE;
 959         }else
 960             if(Points[1].x > Points[3].x)
 961                 return FALSE;
 962         if(Points[2].x < Points[0].x){
 963             if(Points[2].x < Points[3].x)
 964                 return FALSE;
 965         }else
 966             if(Points[2].x > Points[3].x)
 967                 return FALSE;
 968         dx=BEZIERSHIFTDOWN(dx);
 969         if(!dx) return TRUE;
 970         if(abs(Points[1].y-Points[0].y-(dy/dx)*
 971                 BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
 972            abs(Points[2].y-Points[0].y-(dy/dx)*
 973                    BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
 974             return FALSE;
 975         else
 976             return TRUE;
 977     }else{ /* steep line */
 978         /* check that control points are between begin and end */
 979         if(Points[1].y < Points[0].y){
 980             if(Points[1].y < Points[3].y)
 981                 return FALSE;
 982         }else
 983             if(Points[1].y > Points[3].y)
 984                 return FALSE;
 985         if(Points[2].y < Points[0].y){
 986             if(Points[2].y < Points[3].y)
 987                 return FALSE;
 988         }else
 989             if(Points[2].y > Points[3].y)
 990                 return FALSE;
 991         dy=BEZIERSHIFTDOWN(dy);
 992         if(!dy) return TRUE;
 993         if(abs(Points[1].x-Points[0].x-(dx/dy)*
 994                 BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
 995            abs(Points[2].x-Points[0].x-(dx/dy)*
 996                    BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
 997             return FALSE;
 998         else
 999             return TRUE;
1000     }
1001 }
1002
1003 /* Helper for GDI_Bezier.
1004  * Just handles one Bezier, so Points should point to four POINTs
1005  */
1006 static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,
1007                                 INT *nPtsOut, INT level )
1008 {
1009     if(*nPtsOut == *dwOut) {
1010         *dwOut *= 2;
1011         *PtsOut = HeapReAlloc( GetProcessHeap(), 0, *PtsOut,
1012                                *dwOut * sizeof(POINT) );
1013     }
1014
1015     if(!level || BezierCheck(level, Points)) {
1016         if(*nPtsOut == 0) {
1017             (*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x);
1018             (*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y);
1019             *nPtsOut = 1;
1020         }
1021         (*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x);
1022         (*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y);
1023         (*nPtsOut) ++;
1024     } else {
1025         POINT Points2[4]; /* for the second recursive call */
1026         Points2[3]=Points[3];
1027         BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
1028         BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
1029         BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
1030
1031         BEZIERMIDDLE(Points[1], Points[0],  Points[1]);
1032         BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
1033         BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
1034
1035         Points2[0]=Points[3];
1036
1037         /* do the two halves */
1038         GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1);
1039         GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1);
1040     }
1041 }
1042
1043
1044
1045 /***********************************************************************
1046  *           GDI_Bezier   [INTERNAL]
1047  *   Calculate line segments that approximate -what microsoft calls- a bezier
1048  *   curve.
1049  *   The routine recursively divides the curve in two parts until a straight
1050  *   line can be drawn
1051  *
1052  *  PARAMS
1053  *
1054  *  Points  [I] Ptr to count POINTs which are the end and control points
1055  *              of the set of Bezier curves to flatten.
1056  *  count   [I] Number of Points.  Must be 3n+1.
1057  *  nPtsOut [O] Will contain no of points that have been produced (i.e. no. of
1058  *              lines+1).
1059  *
1060  *  RETURNS
1061  *
1062  *  Ptr to an array of POINTs that contain the lines that approximate the
1063  *  Beziers.  The array is allocated on the process heap and it is the caller's
1064  *  responsibility to HeapFree it. [this is not a particularly nice interface
1065  *  but since we can't know in advance how many points we will generate, the
1066  *  alternative would be to call the function twice, once to determine the size
1067  *  and a second time to do the work - I decided this was too much of a pain].
1068  */
1069 POINT *GDI_Bezier( const POINT *Points, INT count, INT *nPtsOut )
1070 {
1071     POINT *out;
1072     INT Bezier, dwOut = BEZIER_INITBUFSIZE, i;
1073
1074     if (count == 1 || (count - 1) % 3 != 0) {
1075         ERR("Invalid no. of points %d\n", count);
1076         return NULL;
1077     }
1078     *nPtsOut = 0;
1079     out = HeapAlloc( GetProcessHeap(), 0, dwOut * sizeof(POINT));
1080     for(Bezier = 0; Bezier < (count-1)/3; Bezier++) {
1081         POINT ptBuf[4];
1082         memcpy(ptBuf, Points + Bezier * 3, sizeof(POINT) * 4);
1083         for(i = 0; i < 4; i++) {
1084             ptBuf[i].x = BEZIERSHIFTUP(ptBuf[i].x);
1085             ptBuf[i].y = BEZIERSHIFTUP(ptBuf[i].y);
1086         }
1087         GDI_InternalBezier( ptBuf, &out, &dwOut, nPtsOut, BEZIERMAXDEPTH );
1088     }
1089     TRACE("Produced %d points\n", *nPtsOut);
1090     return out;
1091 }
1092
1093 /******************************************************************************
1094  *           GdiGradientFill   (GDI32.@)
1095  */
1096 BOOL WINAPI GdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
1097                              void *grad_array, ULONG ngrad, ULONG mode )
1098 {
1099     DC *dc;
1100     PHYSDEV physdev;
1101     BOOL ret;
1102     ULONG i;
1103
1104     TRACE("%p vert_array:%p nvert:%d grad_array:%p ngrad:%d\n", hdc, vert_array, nvert, grad_array, ngrad);
1105
1106     if (!vert_array || !nvert || !grad_array || !ngrad || mode > GRADIENT_FILL_TRIANGLE)
1107     {
1108         SetLastError( ERROR_INVALID_PARAMETER );
1109         return FALSE;
1110     }
1111     for (i = 0; i < ngrad * (mode == GRADIENT_FILL_TRIANGLE ? 3 : 2); i++)
1112         if (((ULONG *)grad_array)[i] >= nvert) return FALSE;
1113
1114     if (!(dc = get_dc_ptr( hdc )))
1115     {
1116         SetLastError( ERROR_INVALID_PARAMETER );
1117         return FALSE;
1118     }
1119     update_dc( dc );
1120     physdev = GET_DC_PHYSDEV( dc, pGradientFill );
1121     ret = physdev->funcs->pGradientFill( physdev, vert_array, nvert, grad_array, ngrad, mode );
1122     release_dc_ptr( dc );
1123     return ret;
1124 }
1125
1126 /******************************************************************************
1127  *           GdiDrawStream   (GDI32.@)
1128  *
1129  */
1130 BOOL WINAPI GdiDrawStream( HDC hdc, ULONG in, void * pvin )
1131 {
1132     FIXME("stub: %p, %d, %p\n", hdc, in, pvin);
1133     return FALSE;
1134 }