graphics/painting.c

   1 /*
   2  * Misc. graphics operations
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  * Copyright 1997 Bertho A. Stultiens
   6  */
   7
   8 #include <string.h>
   9 #include "dc.h"
  10 #include "bitmap.h"
  11 #include "heap.h"
  12 #include "monitor.h"
  13 #include "cache.h"
  14 #include "region.h"
  15 #include "path.h"
  16 #include "debugtools.h"
  17 #include "winerror.h"
  18 #include "winuser.h"
  19 #include "wine/winuser16.h"
  20
  21 DEFAULT_DEBUG_CHANNEL(gdi)
  22
  23
  24 /***********************************************************************
  25  *           LineTo16    (GDI.19)
  26  */
  27 BOOL16 WINAPI LineTo16( HDC16 hdc, INT16 x, INT16 y )
  28 {
  29     return LineTo( hdc, x, y );
  30 }
  31
  32
  33 /***********************************************************************
  34  *           LineTo    (GDI32.249)
  35  */
  36 BOOL WINAPI LineTo( HDC hdc, INT x, INT y )
  37 {
  38     DC * dc = DC_GetDCPtr( hdc );
  39     BOOL ret;
  40
  41     if(!dc) return FALSE;
  42
  43     if(PATH_IsPathOpen(dc->w.path))
  44         ret = PATH_LineTo(hdc, x, y);
  45     else
  46         ret = dc->funcs->pLineTo && dc->funcs->pLineTo(dc,x,y);
  47     if(ret) {
  48         dc->w.CursPosX = x;
  49         dc->w.CursPosY = y;
  50     }
  51     return ret;
  52 }
  53
  54
  55 /***********************************************************************
  56  *           MoveTo16    (GDI.20)
  57  */
  58 DWORD WINAPI MoveTo16( HDC16 hdc, INT16 x, INT16 y )
  59 {
  60     POINT16     pt;
  61
  62     if (!MoveToEx16(hdc,x,y,&pt))
  63         return 0;
  64     return MAKELONG(pt.x,pt.y);
  65 }
  66
  67
  68 /***********************************************************************
  69  *           MoveToEx16    (GDI.483)
  70  */
  71 BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
  72 {
  73     POINT pt32;
  74
  75     if (!MoveToEx( (HDC)hdc, (INT)x, (INT)y, &pt32 )) return FALSE;
  76     if (pt) CONV_POINT32TO16( &pt32, pt );
  77     return TRUE;
  78
  79 }
  80
  81
  82 /***********************************************************************
  83  *           MoveToEx    (GDI32.254)
  84  */
  85 BOOL WINAPI MoveToEx( HDC hdc, INT x, INT y, LPPOINT pt )
  86 {
  87     DC * dc = DC_GetDCPtr( hdc );
  88
  89     if(!dc) return FALSE;
  90
  91     if(pt) {
  92         pt->x = dc->w.CursPosX;
  93         pt->y = dc->w.CursPosY;
  94     }
  95     dc->w.CursPosX = x;
  96     dc->w.CursPosY = y;
  97
  98     if(PATH_IsPathOpen(dc->w.path))
  99         return PATH_MoveTo(hdc);
 100
 101     if(dc->funcs->pMoveToEx)
 102         return dc->funcs->pMoveToEx(dc,x,y,pt);
 103     return TRUE;
 104 }
 105
 106
 107 /***********************************************************************
 108  *           Arc16    (GDI.23)
 109  */
 110 BOOL16 WINAPI Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 111                      INT16 bottom, INT16 xstart, INT16 ystart,
 112                      INT16 xend, INT16 yend )
 113 {
 114     return Arc( (HDC)hdc, (INT)left, (INT)top, (INT)right,
 115                   (INT)bottom, (INT)xstart, (INT)ystart, (INT)xend,
 116                   (INT)yend );
 117 }
 118
 119
 120 /***********************************************************************
 121  *           Arc    (GDI32.7)
 122  */
 123 BOOL WINAPI Arc( HDC hdc, INT left, INT top, INT right,
 124                      INT bottom, INT xstart, INT ystart,
 125                      INT xend, INT yend )
 126 {
 127     DC * dc = DC_GetDCPtr( hdc );
 128
 129     if(dc && PATH_IsPathOpen(dc->w.path))
 130         return PATH_Arc(hdc, left, top, right, bottom, xstart, ystart, xend,
 131            yend);
 132
 133     return dc && dc->funcs->pArc &&
 134            dc->funcs->pArc(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 135 }
 136
 137 /***********************************************************************
 138  *           ArcTo    (GDI32.8)
 139  */
 140 BOOL WINAPI ArcTo( HDC hdc,
 141                      INT left,   INT top,
 142                      INT right,  INT bottom,
 143                      INT xstart, INT ystart,
 144                      INT xend,   INT yend )
 145 {
 146     BOOL result;
 147     DC * dc = DC_GetDCPtr( hdc );
 148
 149     if(!dc) return FALSE;
 150
 151     if(dc->funcs->pArcTo)
 152         return dc->funcs->pArcTo( dc, left, top, right, bottom,
 153                                   xstart, ystart, xend, yend );
 154     /*
 155      * Else emulate it.
 156      * According to the documentation, a line is drawn from the current
 157      * position to the starting point of the arc.
 158      */
 159     LineTo(hdc, xstart, ystart);
 160
 161     /*
 162      * Then the arc is drawn.
 163      */
 164     result = Arc(hdc,
 165                   left, top,
 166                   right, bottom,
 167                   xstart, ystart,
 168                   xend, yend);
 169
 170     /*
 171      * If no error occured, the current position is moved to the ending
 172      * point of the arc.
 173      */
 174     if (result)
 175     {
 176         MoveToEx(hdc, xend, yend, NULL);
 177     }
 178
 179     return result;
 180 }
 181
 182 /***********************************************************************
 183  *           Pie16    (GDI.26)
 184  */
 185 BOOL16 WINAPI Pie16( HDC16 hdc, INT16 left, INT16 top,
 186                      INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 187                      INT16 xend, INT16 yend )
 188 {
 189     return Pie( (HDC)hdc, (INT)left, (INT)top, (INT)right,
 190                   (INT)bottom, (INT)xstart, (INT)ystart, (INT)xend,
 191                   (INT)yend );
 192 }
 193
 194
 195 /***********************************************************************
 196  *           Pie   (GDI32.262)
 197  */
 198 BOOL WINAPI Pie( HDC hdc, INT left, INT top,
 199                      INT right, INT bottom, INT xstart, INT ystart,
 200                      INT xend, INT yend )
 201 {
 202     DC * dc = DC_GetDCPtr( hdc );
 203
 204     return dc && dc->funcs->pPie &&
 205            dc->funcs->pPie(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 206 }
 207
 208
 209 /***********************************************************************
 210  *           Chord16    (GDI.348)
 211  */
 212 BOOL16 WINAPI Chord16( HDC16 hdc, INT16 left, INT16 top,
 213                        INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
 214                        INT16 xend, INT16 yend )
 215 {
 216     return Chord( hdc, left, top, right, bottom, xstart, ystart, xend, yend );
 217 }
 218
 219
 220 /***********************************************************************
 221  *           Chord    (GDI32.14)
 222  */
 223 BOOL WINAPI Chord( HDC hdc, INT left, INT top,
 224                        INT right, INT bottom, INT xstart, INT ystart,
 225                        INT xend, INT yend )
 226 {
 227     DC * dc = DC_GetDCPtr( hdc );
 228
 229     return dc && dc->funcs->pChord &&
 230            dc->funcs->pChord(dc,left,top,right,bottom,xstart,ystart,xend,yend);
 231 }
 232
 233
 234 /***********************************************************************
 235  *           Ellipse16    (GDI.24)
 236  */
 237 BOOL16 WINAPI Ellipse16( HDC16 hdc, INT16 left, INT16 top,
 238                          INT16 right, INT16 bottom )
 239 {
 240     return Ellipse( hdc, left, top, right, bottom );
 241 }
 242
 243
 244 /***********************************************************************
 245  *           Ellipse    (GDI32.75)
 246  */
 247 BOOL WINAPI Ellipse( HDC hdc, INT left, INT top,
 248                          INT right, INT bottom )
 249 {
 250     DC * dc = DC_GetDCPtr( hdc );
 251
 252     return dc && dc->funcs->pEllipse &&
 253            dc->funcs->pEllipse(dc,left,top,right,bottom);
 254 }
 255
 256
 257 /***********************************************************************
 258  *           Rectangle16    (GDI.27)
 259  */
 260 BOOL16 WINAPI Rectangle16( HDC16 hdc, INT16 left, INT16 top,
 261                            INT16 right, INT16 bottom )
 262 {
 263     return Rectangle( hdc, left, top, right, bottom );
 264 }
 265
 266
 267 /***********************************************************************
 268  *           Rectangle    (GDI32.283)
 269  */
 270 BOOL WINAPI Rectangle( HDC hdc, INT left, INT top,
 271                            INT right, INT bottom )
 272 {
 273     DC * dc = DC_GetDCPtr( hdc );
 274
 275     if(dc && PATH_IsPathOpen(dc->w.path))
 276         return PATH_Rectangle(hdc, left, top, right, bottom);
 277
 278     return dc && dc->funcs->pRectangle &&
 279            dc->funcs->pRectangle(dc,left,top,right,bottom);
 280 }
 281
 282
 283 /***********************************************************************
 284  *           RoundRect16    (GDI.28)
 285  */
 286 BOOL16 WINAPI RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
 287                            INT16 bottom, INT16 ell_width, INT16 ell_height )
 288 {
 289     return RoundRect( hdc, left, top, right, bottom, ell_width, ell_height );
 290 }
 291
 292
 293 /***********************************************************************
 294  *           RoundRect    (GDI32.291)
 295  */
 296 BOOL WINAPI RoundRect( HDC hdc, INT left, INT top, INT right,
 297                            INT bottom, INT ell_width, INT ell_height )
 298 {
 299
 300     if(ell_width == 0 || ell_height == 0) /* Just an optimization */
 301         return Rectangle(hdc, left, top, right, bottom);
 302
 303     else {
 304         DC * dc = DC_GetDCPtr( hdc );
 305
 306         return dc && dc->funcs->pRoundRect &&
 307            dc->funcs->pRoundRect(dc,left,top,right,bottom,ell_width,ell_height);
 308     }
 309 }
 310
 311 /***********************************************************************
 312  *           SetPixel16    (GDI.31)
 313  */
 314 COLORREF WINAPI SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 315 {
 316     return SetPixel( hdc, x, y, color );
 317 }
 318
 319
 320 /***********************************************************************
 321  *           SetPixel    (GDI32.327)
 322  */
 323 COLORREF WINAPI SetPixel( HDC hdc, INT x, INT y, COLORREF color )
 324 {
 325     DC * dc = DC_GetDCPtr( hdc );
 326
 327     if (!dc || !dc->funcs->pSetPixel) return 0;
 328     return dc->funcs->pSetPixel(dc,x,y,color);
 329 }
 330
 331 /***********************************************************************
 332  *           SetPixelV    (GDI32.329)
 333  */
 334 BOOL WINAPI SetPixelV( HDC hdc, INT x, INT y, COLORREF color )
 335 {
 336     DC * dc = DC_GetDCPtr( hdc );
 337
 338     if (!dc || !dc->funcs->pSetPixel) return FALSE;
 339     dc->funcs->pSetPixel(dc,x,y,color);
 340     return TRUE;
 341 }
 342
 343 /***********************************************************************
 344  *           GetPixel16    (GDI.83)
 345  */
 346 COLORREF WINAPI GetPixel16( HDC16 hdc, INT16 x, INT16 y )
 347 {
 348     return GetPixel( hdc, x, y );
 349 }
 350
 351
 352 /***********************************************************************
 353  *           GetPixel    (GDI32.211)
 354  */
 355 COLORREF WINAPI GetPixel( HDC hdc, INT x, INT y )
 356 {
 357     DC * dc = DC_GetDCPtr( hdc );
 358
 359     if (!dc) return 0;
 360 #ifdef SOLITAIRE_SPEED_HACK
 361     return 0;
 362 #endif
 363
 364     /* FIXME: should this be in the graphics driver? */
 365     if (!PtVisible( hdc, x, y )) return 0;
 366     if (!dc || !dc->funcs->pGetPixel) return 0;
 367     return dc->funcs->pGetPixel(dc,x,y);
 368 }
 369
 370
 371 /******************************************************************************
 372  * ChoosePixelFormat [GDI32.13]
 373  * Matches a pixel format to given format
 374  *
 375  * PARAMS
 376  *    hdc  [I] Device context to search for best pixel match
 377  *    ppfd [I] Pixel format for which a match is sought
 378  *
 379  * RETURNS
 380  *    Success: Pixel format index closest to given format
 381  *    Failure: 0
 382  */
 383 INT WINAPI ChoosePixelFormat( HDC hdc, const PIXELFORMATDESCRIPTOR* ppfd )
 384 {
 385     FIXME("(%d,%p): stub\n",hdc,ppfd);
 386     return 1;
 387 }
 388
 389
 390 /******************************************************************************
 391  * SetPixelFormat [GDI32.328]
 392  * Sets pixel format of device context
 393  *
 394  * PARAMS
 395  *    hdc          [I] Device context to search for best pixel match
 396  *    iPixelFormat [I] Pixel format index
 397  *    ppfd         [I] Pixel format for which a match is sought
 398  *
 399  * RETURNS STD
 400  */
 401 BOOL WINAPI SetPixelFormat( HDC hdc, int iPixelFormat,
 402                               const PIXELFORMATDESCRIPTOR* ppfd)
 403 {
 404     FIXME("(%d,%d,%p): stub\n",hdc,iPixelFormat,ppfd);
 405     return TRUE;
 406 }
 407
 408
 409 /******************************************************************************
 410  * GetPixelFormat [GDI32.212]
 411  * Gets index of pixel format of DC
 412  *
 413  * PARAMETERS
 414  *    hdc [I] Device context whose pixel format index is sought
 415  *
 416  * RETURNS
 417  *    Success: Currently selected pixel format
 418  *    Failure: 0
 419  */
 420 int WINAPI GetPixelFormat( HDC hdc )
 421 {
 422     FIXME("(%d): stub\n",hdc);
 423     return 1;
 424 }
 425
 426
 427 /******************************************************************************
 428  * DescribePixelFormat [GDI32.71]
 429  * Gets info about pixel format from DC
 430  *
 431  * PARAMS
 432  *    hdc          [I] Device context
 433  *    iPixelFormat [I] Pixel format selector
 434  *    nBytes       [I] Size of buffer
 435  *    ppfd         [O] Pointer to structure to receive pixel format data
 436  *
 437  * RETURNS
 438  *    Success: Maximum pixel format index of the device context
 439  *    Failure: 0
 440  */
 441 int WINAPI DescribePixelFormat( HDC hdc, int iPixelFormat, UINT nBytes,
 442                                 LPPIXELFORMATDESCRIPTOR ppfd )
 443 {
 444     FIXME("(%d,%d,%d,%p): stub\n",hdc,iPixelFormat,nBytes,ppfd);
 445     ppfd->nSize = nBytes;
 446     ppfd->nVersion = 1;
 447     return 3;
 448 }
 449
 450
 451 /******************************************************************************
 452  * SwapBuffers [GDI32.354]
 453  * Exchanges front and back buffers of window
 454  *
 455  * PARAMS
 456  *    hdc [I] Device context whose buffers get swapped
 457  *
 458  * RETURNS STD
 459  */
 460 BOOL WINAPI SwapBuffers( HDC hdc )
 461 {
 462     FIXME("(%d): stub\n",hdc);
 463     return TRUE;
 464 }
 465
 466
 467 /***********************************************************************
 468  *           PaintRgn16    (GDI.43)
 469  */
 470 BOOL16 WINAPI PaintRgn16( HDC16 hdc, HRGN16 hrgn )
 471 {
 472     return PaintRgn( hdc, hrgn );
 473 }
 474
 475
 476 /***********************************************************************
 477  *           PaintRgn    (GDI32.259)
 478  */
 479 BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
 480 {
 481     DC * dc = DC_GetDCPtr( hdc );
 482
 483     return dc && dc->funcs->pPaintRgn &&
 484            dc->funcs->pPaintRgn(dc,hrgn);
 485 }
 486
 487
 488 /***********************************************************************
 489  *           FillRgn16    (GDI.40)
 490  */
 491 BOOL16 WINAPI FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
 492 {
 493     return FillRgn( hdc, hrgn, hbrush );
 494 }
 495
 496
 497 /***********************************************************************
 498  *           FillRgn    (GDI32.101)
 499  */
 500 BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
 501 {
 502     BOOL retval;
 503     HBRUSH prevBrush;
 504     DC * dc = DC_GetDCPtr( hdc );
 505
 506     if (!dc) return FALSE;
 507     if(dc->funcs->pFillRgn)
 508         return dc->funcs->pFillRgn(dc, hrgn, hbrush);
 509
 510     prevBrush = SelectObject( hdc, hbrush );
 511     if (!prevBrush) return FALSE;
 512     retval = PaintRgn( hdc, hrgn );
 513     SelectObject( hdc, prevBrush );
 514     return retval;
 515 }
 516
 517
 518 /***********************************************************************
 519  *           FrameRgn16     (GDI.41)
 520  */
 521 BOOL16 WINAPI FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
 522                           INT16 nWidth, INT16 nHeight )
 523 {
 524     return FrameRgn( hdc, hrgn, hbrush, nWidth, nHeight );
 525 }
 526
 527
 528 /***********************************************************************
 529  *           FrameRgn     (GDI32.105)
 530  */
 531 BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush,
 532                           INT nWidth, INT nHeight )
 533 {
 534     HRGN tmp;
 535     DC *dc = DC_GetDCPtr( hdc );
 536
 537     if(dc->funcs->pFrameRgn)
 538         return dc->funcs->pFrameRgn( dc, hrgn, hbrush, nWidth, nHeight );
 539
 540     tmp = CreateRectRgn( 0, 0, 0, 0 );
 541     if(!REGION_FrameRgn( tmp, hrgn, nWidth, nHeight )) return FALSE;
 542     FillRgn( hdc, tmp, hbrush );
 543     DeleteObject( tmp );
 544     return TRUE;
 545 }
 546
 547
 548 /***********************************************************************
 549  *           InvertRgn16    (GDI.42)
 550  */
 551 BOOL16 WINAPI InvertRgn16( HDC16 hdc, HRGN16 hrgn )
 552 {
 553     return InvertRgn( hdc, hrgn );
 554 }
 555
 556
 557 /***********************************************************************
 558  *           InvertRgn    (GDI32.246)
 559  */
 560 BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
 561 {
 562     HBRUSH prevBrush;
 563     INT prevROP;
 564     BOOL retval;
 565     DC *dc = DC_GetDCPtr( hdc );
 566
 567     if(dc->funcs->pInvertRgn)
 568         return dc->funcs->pInvertRgn( dc, hrgn );
 569
 570     prevBrush = SelectObject( hdc, GetStockObject(BLACK_BRUSH) );
 571     prevROP = SetROP2( hdc, R2_NOT );
 572     retval = PaintRgn( hdc, hrgn );
 573     SelectObject( hdc, prevBrush );
 574     SetROP2( hdc, prevROP );
 575     return retval;
 576 }
 577
 578 /**********************************************************************
 579  *          Polyline16  (GDI.37)
 580  */
 581 BOOL16 WINAPI Polyline16( HDC16 hdc, const POINT16* pt, INT16 count )
 582 {
 583     register int i;
 584     BOOL16 ret;
 585     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
 586                                            count*sizeof(POINT) );
 587
 588     if (!pt32) return FALSE;
 589     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 590     ret = Polyline(hdc,pt32,count);
 591     HeapFree( GetProcessHeap(), 0, pt32 );
 592     return ret;
 593 }
 594
 595
 596 /**********************************************************************
 597  *          Polyline   (GDI32.276)
 598  */
 599 BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count )
 600 {
 601     DC * dc = DC_GetDCPtr( hdc );
 602
 603     return dc && dc->funcs->pPolyline &&
 604            dc->funcs->pPolyline(dc,pt,count);
 605 }
 606
 607 /**********************************************************************
 608  *          PolylineTo   (GDI32.277)
 609  */
 610 BOOL WINAPI PolylineTo( HDC hdc, const POINT* pt, DWORD cCount )
 611 {
 612     DC * dc = DC_GetDCPtr( hdc );
 613     BOOL ret;
 614
 615     if(!dc) return FALSE;
 616
 617     if(dc->funcs->pPolylineTo)
 618         ret = dc->funcs->pPolylineTo(dc, pt, cCount);
 619
 620     else { /* do it using Polyline */
 621         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 622                                 sizeof(POINT) * (cCount + 1) );
 623         if(!pts) return FALSE;
 624
 625         pts[0].x = dc->w.CursPosX;
 626         pts[0].y = dc->w.CursPosY;
 627         memcpy( pts + 1, pt, sizeof(POINT) * cCount );
 628         ret = Polyline( hdc, pts, cCount + 1 );
 629         HeapFree( GetProcessHeap(), 0, pts );
 630     }
 631     if(ret) {
 632         dc->w.CursPosX = pt[cCount-1].x;
 633         dc->w.CursPosY = pt[cCount-1].y;
 634     }
 635     return ret;
 636 }
 637
 638 /**********************************************************************
 639  *          Polygon16  (GDI.36)
 640  */
 641 BOOL16 WINAPI Polygon16( HDC16 hdc, const POINT16* pt, INT16 count )
 642 {
 643     register int i;
 644     BOOL ret;
 645     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
 646                                            count*sizeof(POINT) );
 647
 648     if (!pt32) return FALSE;
 649     for (i=count;i--;) CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 650     ret = Polygon(hdc,pt32,count);
 651     HeapFree( GetProcessHeap(), 0, pt32 );
 652     return ret;
 653 }
 654
 655
 656 /**********************************************************************
 657  *          Polygon  (GDI32.275)
 658  */
 659 BOOL WINAPI Polygon( HDC hdc, const POINT* pt, INT count )
 660 {
 661     DC * dc = DC_GetDCPtr( hdc );
 662
 663     return dc && dc->funcs->pPolygon &&
 664            dc->funcs->pPolygon(dc,pt,count);
 665 }
 666
 667
 668 /**********************************************************************
 669  *          PolyPolygon16  (GDI.450)
 670  */
 671 BOOL16 WINAPI PolyPolygon16( HDC16 hdc, const POINT16* pt, const INT16* counts,
 672                              UINT16 polygons )
 673 {
 674     int         i,nrpts;
 675     LPPOINT     pt32;
 676     LPINT       counts32;
 677     BOOL16      ret;
 678
 679     nrpts=0;
 680     for (i=polygons;i--;)
 681         nrpts+=counts[i];
 682     pt32 = (LPPOINT)HEAP_xalloc( GetProcessHeap(), 0, sizeof(POINT)*nrpts);
 683     for (i=nrpts;i--;)
 684         CONV_POINT16TO32(&(pt[i]),&(pt32[i]));
 685     counts32 = (LPINT)HEAP_xalloc( GetProcessHeap(), 0,
 686                                      polygons*sizeof(INT) );
 687     for (i=polygons;i--;) counts32[i]=counts[i];
 688
 689     ret = PolyPolygon(hdc,pt32,counts32,polygons);
 690     HeapFree( GetProcessHeap(), 0, counts32 );
 691     HeapFree( GetProcessHeap(), 0, pt32 );
 692     return ret;
 693 }
 694
 695 /**********************************************************************
 696  *          PolyPolygon  (GDI.450)
 697  */
 698 BOOL WINAPI PolyPolygon( HDC hdc, const POINT* pt, const INT* counts,
 699                              UINT polygons )
 700 {
 701     DC * dc = DC_GetDCPtr( hdc );
 702
 703     return dc && dc->funcs->pPolyPolygon &&
 704            dc->funcs->pPolyPolygon(dc,pt,counts,polygons);
 705 }
 706
 707 /**********************************************************************
 708  *          PolyPolyline  (GDI32.272)
 709  */
 710 BOOL WINAPI PolyPolyline( HDC hdc, const POINT* pt, const DWORD* counts,
 711                             DWORD polylines )
 712 {
 713     DC * dc = DC_GetDCPtr( hdc );
 714
 715     return dc && dc->funcs->pPolyPolyline &&
 716            dc->funcs->pPolyPolyline(dc,pt,counts,polylines);
 717 }
 718
 719 /**********************************************************************
 720  *          ExtFloodFill16   (GDI.372)
 721  */
 722 BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
 723                               UINT16 fillType )
 724 {
 725     return ExtFloodFill( hdc, x, y, color, fillType );
 726 }
 727
 728
 729 /**********************************************************************
 730  *          ExtFloodFill   (GDI32.96)
 731  */
 732 BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color,
 733                               UINT fillType )
 734 {
 735     DC *dc = DC_GetDCPtr( hdc );
 736
 737     return dc && dc->funcs->pExtFloodFill &&
 738            dc->funcs->pExtFloodFill(dc,x,y,color,fillType);
 739 }
 740
 741
 742 /**********************************************************************
 743  *          FloodFill16   (GDI.25)
 744  */
 745 BOOL16 WINAPI FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
 746 {
 747     return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER );
 748 }
 749
 750
 751 /**********************************************************************
 752  *          FloodFill   (GDI32.104)
 753  */
 754 BOOL WINAPI FloodFill( HDC hdc, INT x, INT y, COLORREF color )
 755 {
 756     return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER );
 757 }
 758
 759
 760 /******************************************************************************
 761  * PolyBezier16 [GDI.502]
 762  */
 763 BOOL16 WINAPI PolyBezier16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
 764 {
 765     int i;
 766     BOOL16 ret;
 767     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
 768                                            cPoints*sizeof(POINT) );
 769     if(!pt32) return FALSE;
 770     for (i=cPoints;i--;) CONV_POINT16TO32(&(lppt[i]),&(pt32[i]));
 771     ret= PolyBezier(hDc, pt32, cPoints);
 772     HeapFree( GetProcessHeap(), 0, pt32 );
 773     return ret;
 774 }
 775
 776 /******************************************************************************
 777  * PolyBezierTo16 [GDI.503]
 778  */
 779 BOOL16 WINAPI PolyBezierTo16( HDC16 hDc, const POINT16* lppt, INT16 cPoints )
 780 {
 781     int i;
 782     BOOL16 ret;
 783     LPPOINT pt32 = (LPPOINT)HeapAlloc( GetProcessHeap(), 0,
 784                                            cPoints*sizeof(POINT) );
 785     if(!pt32) return FALSE;
 786     for (i=cPoints;i--;) CONV_POINT16TO32(&(lppt[i]),&(pt32[i]));
 787     ret= PolyBezierTo(hDc, pt32, cPoints);
 788     HeapFree( GetProcessHeap(), 0, pt32 );
 789     return ret;
 790 }
 791
 792 /******************************************************************************
 793  * PolyBezier [GDI32.268]
 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 STD
 802  */
 803 BOOL WINAPI PolyBezier( HDC hdc, const POINT* lppt, DWORD cPoints )
 804 {
 805     DC * dc = DC_GetDCPtr( hdc );
 806
 807     return dc && dc->funcs->pPolyBezier &&
 808            dc->funcs->pPolyBezier(dc, lppt, cPoints);
 809 }
 810
 811 /******************************************************************************
 812  * PolyBezierTo [GDI32.269]
 813  * Draws one or more Bezier curves
 814  *
 815  * PARAMS
 816  *    hDc     [I] Handle to device context
 817  *    lppt    [I] Pointer to endpoints and control points
 818  *    cPoints [I] Count of endpoints and control points
 819  *
 820  * RETURNS STD
 821  */
 822 BOOL WINAPI PolyBezierTo( HDC hdc, const POINT* lppt, DWORD cPoints )
 823 {
 824     DC * dc = DC_GetDCPtr( hdc );
 825     BOOL ret;
 826
 827     if(!dc) return FALSE;
 828
 829     if(PATH_IsPathOpen(dc->w.path))
 830         ret = PATH_PolyBezierTo(hdc, lppt, cPoints);
 831     else
 832         ret = dc->funcs->pPolyBezierTo &&
 833             dc->funcs->pPolyBezierTo(dc, lppt, cPoints);
 834
 835     if(ret) {
 836         dc->w.CursPosX = lppt[cPoints-1].x;
 837         dc->w.CursPosY = lppt[cPoints-1].y;
 838     }
 839     return ret;
 840 }
 841
 842 /***************************************************************
 843  *      AngleArc (GDI32.5)
 844  *
 845  */
 846 BOOL WINAPI AngleArc(HDC hdc, INT x, INT y, DWORD dwRadius,
 847                        FLOAT eStartAngle, FLOAT eSweepAngle)
 848 {
 849         FIXME("AngleArc, stub\n");
 850         return 0;
 851 }
 852
 853 /***************************************************************
 854  *      PolyDraw (GDI32.270)
 855  *
 856  */
 857 BOOL WINAPI PolyDraw(HDC hdc, const POINT *lppt, const BYTE *lpbTypes,
 858                        DWORD cCount)
 859 {
 860         FIXME("PolyDraw, stub\n");
 861         return 0;
 862 }