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