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