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     update_dc( dc );
 376     if (!dc->funcs->pSetPixelFormat) FIXME(" :stub\n");
 377     else bRet = dc->funcs->pSetPixelFormat(dc->physDev,iPixelFormat,ppfd);
 378
 379     release_dc_ptr( dc );
 380     return bRet;
 381 }
 382
 383
 384 /******************************************************************************
 385  * GetPixelFormat [GDI32.@]
 386  * Gets index of pixel format of DC
 387  *
 388  * PARAMETERS
 389  *    hdc [I] Device context whose pixel format index is sought
 390  *
 391  * RETURNS
 392  *    Success: Currently selected pixel format
 393  *    Failure: 0
 394  */
 395 INT WINAPI GetPixelFormat( HDC hdc )
 396 {
 397     INT ret = 0;
 398     DC * dc = get_dc_ptr( hdc );
 399
 400     TRACE("(%p)\n",hdc);
 401
 402     if (!dc) return 0;
 403
 404     update_dc( dc );
 405     if (!dc->funcs->pGetPixelFormat) FIXME(" :stub\n");
 406     else ret = dc->funcs->pGetPixelFormat(dc->physDev);
 407
 408     release_dc_ptr( dc );
 409     return ret;
 410 }
 411
 412
 413 /******************************************************************************
 414  * DescribePixelFormat [GDI32.@]
 415  * Gets info about pixel format from DC
 416  *
 417  * PARAMS
 418  *    hdc          [I] Device context
 419  *    iPixelFormat [I] Pixel format selector
 420  *    nBytes       [I] Size of buffer
 421  *    ppfd         [O] Pointer to structure to receive pixel format data
 422  *
 423  * RETURNS
 424  *    Success: Maximum pixel format index of the device context
 425  *    Failure: 0
 426  */
 427 INT WINAPI DescribePixelFormat( HDC hdc, INT iPixelFormat, UINT nBytes,
 428                                 LPPIXELFORMATDESCRIPTOR ppfd )
 429 {
 430     INT ret = 0;
 431     DC * dc = get_dc_ptr( hdc );
 432
 433     TRACE("(%p,%d,%d,%p): stub\n",hdc,iPixelFormat,nBytes,ppfd);
 434
 435     if (!dc) return 0;
 436
 437     update_dc( dc );
 438     if (!dc->funcs->pDescribePixelFormat)
 439     {
 440         FIXME(" :stub\n");
 441         ppfd->nSize = nBytes;
 442         ppfd->nVersion = 1;
 443         ret = 3;
 444     }
 445     else ret = dc->funcs->pDescribePixelFormat(dc->physDev,iPixelFormat,nBytes,ppfd);
 446
 447     release_dc_ptr( dc );
 448     return ret;
 449 }
 450
 451
 452 /******************************************************************************
 453  * SwapBuffers [GDI32.@]
 454  * Exchanges front and back buffers of window
 455  *
 456  * PARAMS
 457  *    hdc [I] Device context whose buffers get swapped
 458  *
 459  * RETURNS
 460  *    Success: TRUE
 461  *    Failure: FALSE
 462  */
 463 BOOL WINAPI SwapBuffers( HDC hdc )
 464 {
 465     INT bRet = FALSE;
 466     DC * dc = get_dc_ptr( hdc );
 467
 468     TRACE("(%p)\n",hdc);
 469
 470     if (!dc) return TRUE;
 471
 472     update_dc( dc );
 473     if (!dc->funcs->pSwapBuffers)
 474     {
 475         FIXME(" :stub\n");
 476         bRet = TRUE;
 477     }
 478     else bRet = dc->funcs->pSwapBuffers(dc->physDev);
 479
 480     release_dc_ptr( dc );
 481     return bRet;
 482 }
 483
 484
 485 /***********************************************************************
 486  *           PaintRgn    (GDI32.@)
 487  */
 488 BOOL WINAPI PaintRgn( HDC hdc, HRGN hrgn )
 489 {
 490     BOOL ret = FALSE;
 491     DC * dc = get_dc_ptr( hdc );
 492
 493     if (dc)
 494     {
 495         update_dc( dc );
 496         if (dc->funcs->pPaintRgn) ret = dc->funcs->pPaintRgn(dc->physDev,hrgn);
 497         release_dc_ptr( dc );
 498     }
 499     return ret;
 500 }
 501
 502
 503 /***********************************************************************
 504  *           FillRgn    (GDI32.@)
 505  */
 506 BOOL WINAPI FillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush )
 507 {
 508     BOOL retval = FALSE;
 509     HBRUSH prevBrush;
 510     DC * dc = get_dc_ptr( hdc );
 511
 512     if (!dc) return FALSE;
 513     if(dc->funcs->pFillRgn)
 514     {
 515         update_dc( dc );
 516         retval = dc->funcs->pFillRgn(dc->physDev, hrgn, hbrush);
 517     }
 518     else if ((prevBrush = SelectObject( hdc, hbrush )))
 519     {
 520         retval = PaintRgn( hdc, hrgn );
 521         SelectObject( hdc, prevBrush );
 522     }
 523     release_dc_ptr( dc );
 524     return retval;
 525 }
 526
 527
 528 /***********************************************************************
 529  *           FrameRgn     (GDI32.@)
 530  */
 531 BOOL WINAPI FrameRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush,
 532                           INT nWidth, INT nHeight )
 533 {
 534     BOOL ret = FALSE;
 535     DC *dc = get_dc_ptr( hdc );
 536
 537     if (!dc) return FALSE;
 538
 539     if(dc->funcs->pFrameRgn)
 540     {
 541         update_dc( dc );
 542         ret = dc->funcs->pFrameRgn( dc->physDev, hrgn, hbrush, nWidth, nHeight );
 543     }
 544     else
 545     {
 546         HRGN tmp = CreateRectRgn( 0, 0, 0, 0 );
 547         if (tmp)
 548         {
 549             if (REGION_FrameRgn( tmp, hrgn, nWidth, nHeight ))
 550             {
 551                 FillRgn( hdc, tmp, hbrush );
 552                 ret = TRUE;
 553             }
 554             DeleteObject( tmp );
 555         }
 556     }
 557     release_dc_ptr( dc );
 558     return ret;
 559 }
 560
 561
 562 /***********************************************************************
 563  *           InvertRgn    (GDI32.@)
 564  */
 565 BOOL WINAPI InvertRgn( HDC hdc, HRGN hrgn )
 566 {
 567     HBRUSH prevBrush;
 568     INT prevROP;
 569     BOOL retval;
 570     DC *dc = get_dc_ptr( hdc );
 571     if (!dc) return FALSE;
 572
 573     if(dc->funcs->pInvertRgn)
 574     {
 575         update_dc( dc );
 576         retval = dc->funcs->pInvertRgn( dc->physDev, hrgn );
 577     }
 578     else
 579     {
 580         prevBrush = SelectObject( hdc, GetStockObject(BLACK_BRUSH) );
 581         prevROP = SetROP2( hdc, R2_NOT );
 582         retval = PaintRgn( hdc, hrgn );
 583         SelectObject( hdc, prevBrush );
 584         SetROP2( hdc, prevROP );
 585     }
 586     release_dc_ptr( dc );
 587     return retval;
 588 }
 589
 590
 591 /**********************************************************************
 592  *          Polyline   (GDI32.@)
 593  */
 594 BOOL WINAPI Polyline( HDC hdc, const POINT* pt, INT count )
 595 {
 596     BOOL ret = FALSE;
 597     DC * dc = get_dc_ptr( hdc );
 598
 599     if (dc)
 600     {
 601         update_dc( dc );
 602         if (PATH_IsPathOpen(dc->path)) ret = PATH_Polyline(dc, pt, count);
 603         else if (dc->funcs->pPolyline) ret = dc->funcs->pPolyline(dc->physDev,pt,count);
 604         release_dc_ptr( dc );
 605     }
 606     return ret;
 607 }
 608
 609 /**********************************************************************
 610  *          PolylineTo   (GDI32.@)
 611  */
 612 BOOL WINAPI PolylineTo( HDC hdc, const POINT* pt, DWORD cCount )
 613 {
 614     DC * dc = get_dc_ptr( hdc );
 615     BOOL ret = FALSE;
 616
 617     if(!dc) return FALSE;
 618
 619     if(PATH_IsPathOpen(dc->path))
 620     {
 621         update_dc( dc );
 622         ret = PATH_PolylineTo(dc, pt, cCount);
 623     }
 624     else if(dc->funcs->pPolylineTo)
 625     {
 626         update_dc( dc );
 627         ret = dc->funcs->pPolylineTo(dc->physDev, pt, cCount);
 628     }
 629     else /* do it using Polyline */
 630     {
 631         POINT *pts = HeapAlloc( GetProcessHeap(), 0,
 632                                 sizeof(POINT) * (cCount + 1) );
 633         if (pts)
 634         {
 635             pts[0].x = dc->CursPosX;
 636             pts[0].y = dc->CursPosY;
 637             memcpy( pts + 1, pt, sizeof(POINT) * cCount );
 638             ret = Polyline( hdc, pts, cCount + 1 );
 639             HeapFree( GetProcessHeap(), 0, pts );
 640         }
 641     }
 642     if(ret) {
 643         dc->CursPosX = pt[cCount-1].x;
 644         dc->CursPosY = pt[cCount-1].y;
 645     }
 646     release_dc_ptr( dc );
 647     return ret;
 648 }
 649
 650
 651 /**********************************************************************
 652  *          Polygon  (GDI32.@)
 653  */
 654 BOOL WINAPI Polygon( HDC hdc, const POINT* pt, INT count )
 655 {
 656     BOOL ret = FALSE;
 657     DC * dc = get_dc_ptr( hdc );
 658
 659     if (dc)
 660     {
 661         update_dc( dc );
 662         if (PATH_IsPathOpen(dc->path)) ret = PATH_Polygon(dc, pt, count);
 663         else if (dc->funcs->pPolygon) ret = dc->funcs->pPolygon(dc->physDev,pt,count);
 664         release_dc_ptr( dc );
 665     }
 666     return ret;
 667 }
 668
 669
 670 /**********************************************************************
 671  *          PolyPolygon  (GDI32.@)
 672  */
 673 BOOL WINAPI PolyPolygon( HDC hdc, const POINT* pt, const INT* counts,
 674                              UINT polygons )
 675 {
 676     BOOL ret = FALSE;
 677     DC * dc = get_dc_ptr( hdc );
 678
 679     if (dc)
 680     {
 681         update_dc( dc );
 682         if (PATH_IsPathOpen(dc->path)) ret = PATH_PolyPolygon(dc, pt, counts, polygons);
 683         else if (dc->funcs->pPolyPolygon) ret = dc->funcs->pPolyPolygon(dc->physDev,pt,counts,polygons);
 684         release_dc_ptr( dc );
 685     }
 686     return ret;
 687 }
 688
 689 /**********************************************************************
 690  *          PolyPolyline  (GDI32.@)
 691  */
 692 BOOL WINAPI PolyPolyline( HDC hdc, const POINT* pt, const DWORD* counts,
 693                             DWORD polylines )
 694 {
 695     BOOL ret = FALSE;
 696     DC * dc = get_dc_ptr( hdc );
 697
 698     if (dc)
 699     {
 700         update_dc( dc );
 701         if (PATH_IsPathOpen(dc->path)) ret = PATH_PolyPolyline(dc, pt, counts, polylines);
 702         else if (dc->funcs->pPolyPolyline) ret = dc->funcs->pPolyPolyline(dc->physDev,pt,counts,polylines);
 703         release_dc_ptr( dc );
 704     }
 705     return ret;
 706 }
 707
 708 /**********************************************************************
 709  *          ExtFloodFill   (GDI32.@)
 710  */
 711 BOOL WINAPI ExtFloodFill( HDC hdc, INT x, INT y, COLORREF color,
 712                               UINT fillType )
 713 {
 714     BOOL ret = FALSE;
 715     DC * dc = get_dc_ptr( hdc );
 716
 717     if (dc)
 718     {
 719         update_dc( dc );
 720         if (dc->funcs->pExtFloodFill) ret = dc->funcs->pExtFloodFill(dc->physDev,x,y,color,fillType);
 721         release_dc_ptr( dc );
 722     }
 723     return ret;
 724 }
 725
 726
 727 /**********************************************************************
 728  *          FloodFill   (GDI32.@)
 729  */
 730 BOOL WINAPI FloodFill( HDC hdc, INT x, INT y, COLORREF color )
 731 {
 732     return ExtFloodFill( hdc, x, y, color, FLOODFILLBORDER );
 733 }
 734
 735
 736 /******************************************************************************
 737  * PolyBezier [GDI32.@]
 738  * Draws one or more Bezier curves
 739  *
 740  * PARAMS
 741  *    hDc     [I] Handle to device context
 742  *    lppt    [I] Pointer to endpoints and control points
 743  *    cPoints [I] Count of endpoints and control points
 744  *
 745  * RETURNS
 746  *    Success: TRUE
 747  *    Failure: FALSE
 748  */
 749 BOOL WINAPI PolyBezier( HDC hdc, const POINT* lppt, DWORD cPoints )
 750 {
 751     BOOL ret = FALSE;
 752     DC * dc;
 753
 754     /* cPoints must be 3 * n + 1 (where n>=1) */
 755     if (cPoints == 1 || (cPoints % 3) != 1) return FALSE;
 756
 757     dc = get_dc_ptr( hdc );
 758     if(!dc) return FALSE;
 759
 760     if(PATH_IsPathOpen(dc->path))
 761     {
 762         update_dc( dc );
 763         ret = PATH_PolyBezier(dc, lppt, cPoints);
 764     }
 765     else if (dc->funcs->pPolyBezier)
 766     {
 767         update_dc( dc );
 768         ret = dc->funcs->pPolyBezier(dc->physDev, lppt, cPoints);
 769     }
 770     else  /* We'll convert it into line segments and draw them using Polyline */
 771     {
 772         POINT *Pts;
 773         INT nOut;
 774
 775         if ((Pts = GDI_Bezier( lppt, cPoints, &nOut )))
 776         {
 777             TRACE("Pts = %p, no = %d\n", Pts, nOut);
 778             ret = Polyline( hdc, Pts, nOut );
 779             HeapFree( GetProcessHeap(), 0, Pts );
 780         }
 781     }
 782
 783     release_dc_ptr( dc );
 784     return ret;
 785 }
 786
 787 /******************************************************************************
 788  * PolyBezierTo [GDI32.@]
 789  * Draws one or more Bezier curves
 790  *
 791  * PARAMS
 792  *    hDc     [I] Handle to device context
 793  *    lppt    [I] Pointer to endpoints and control points
 794  *    cPoints [I] Count of endpoints and control points
 795  *
 796  * RETURNS
 797  *    Success: TRUE
 798  *    Failure: FALSE
 799  */
 800 BOOL WINAPI PolyBezierTo( HDC hdc, const POINT* lppt, DWORD cPoints )
 801 {
 802     DC * dc;
 803     BOOL ret = FALSE;
 804
 805     /* cbPoints must be 3 * n (where n>=1) */
 806     if (!cPoints || (cPoints % 3) != 0) return FALSE;
 807
 808     dc = get_dc_ptr( hdc );
 809     if(!dc) return FALSE;
 810
 811     if(PATH_IsPathOpen(dc->path))
 812     {
 813         update_dc( dc );
 814         ret = PATH_PolyBezierTo(dc, lppt, cPoints);
 815     }
 816     else if(dc->funcs->pPolyBezierTo)
 817     {
 818         update_dc( dc );
 819         ret = dc->funcs->pPolyBezierTo(dc->physDev, lppt, cPoints);
 820     }
 821     else  /* We'll do it using PolyBezier */
 822     {
 823         POINT *pt = HeapAlloc( GetProcessHeap(), 0, sizeof(POINT) * (cPoints + 1) );
 824         if(pt)
 825         {
 826             pt[0].x = dc->CursPosX;
 827             pt[0].y = dc->CursPosY;
 828             memcpy(pt + 1, lppt, sizeof(POINT) * cPoints);
 829             ret = PolyBezier(hdc, pt, cPoints+1);
 830             HeapFree( GetProcessHeap(), 0, pt );
 831         }
 832     }
 833     if(ret) {
 834         dc->CursPosX = lppt[cPoints-1].x;
 835         dc->CursPosY = lppt[cPoints-1].y;
 836     }
 837     release_dc_ptr( dc );
 838     return ret;
 839 }
 840
 841 /***********************************************************************
 842  *      AngleArc (GDI32.@)
 843  */
 844 BOOL WINAPI AngleArc(HDC hdc, INT x, INT y, DWORD dwRadius, FLOAT eStartAngle, FLOAT eSweepAngle)
 845 {
 846     INT x1,y1,x2,y2, arcdir;
 847     BOOL result;
 848     DC *dc;
 849
 850     if( (signed int)dwRadius < 0 )
 851         return FALSE;
 852
 853     dc = get_dc_ptr( hdc );
 854     if(!dc) return FALSE;
 855
 856     /* Calculate the end point */
 857     x2 = x + cos((eStartAngle+eSweepAngle)*M_PI/180) * dwRadius;
 858     y2 = y - sin((eStartAngle+eSweepAngle)*M_PI/180) * dwRadius;
 859
 860     if(!PATH_IsPathOpen(dc->path) && dc->funcs->pAngleArc)
 861     {
 862         update_dc( dc );
 863         result = dc->funcs->pAngleArc( dc->physDev, x, y, dwRadius, eStartAngle, eSweepAngle );
 864     }
 865     else { /* do it using ArcTo */
 866         x1 = x + cos(eStartAngle*M_PI/180) * dwRadius;
 867         y1 = y - sin(eStartAngle*M_PI/180) * dwRadius;
 868
 869         arcdir = SetArcDirection( hdc, eSweepAngle >= 0 ? AD_COUNTERCLOCKWISE : AD_CLOCKWISE);
 870         result = ArcTo( hdc, x-dwRadius, y-dwRadius, x+dwRadius, y+dwRadius,
 871                         x1, y1, x2, y2 );
 872         SetArcDirection( hdc, arcdir );
 873     }
 874     if (result) {
 875         dc->CursPosX = x2;
 876         dc->CursPosY = y2;
 877     }
 878     release_dc_ptr( dc );
 879     return result;
 880 }
 881
 882 /***********************************************************************
 883  *      PolyDraw (GDI32.@)
 884  */
 885 BOOL WINAPI PolyDraw(HDC hdc, const POINT *lppt, const BYTE *lpbTypes,
 886                        DWORD cCount)
 887 {
 888     DC *dc;
 889     BOOL result = FALSE;
 890     POINT * line_pts = NULL, * bzr_pts = NULL, bzr[4];
 891     INT i, num_pts, num_bzr_pts, space, size;
 892
 893     dc = get_dc_ptr( hdc );
 894     if(!dc) return FALSE;
 895
 896     if( PATH_IsPathOpen( dc->path ) )
 897     {
 898         update_dc( dc );
 899         result = PATH_PolyDraw(dc, lppt, lpbTypes, cCount);
 900     }
 901     else if(dc->funcs->pPolyDraw)
 902     {
 903         update_dc( dc );
 904         result = dc->funcs->pPolyDraw( dc->physDev, lppt, lpbTypes, cCount );
 905     }
 906     else {
 907         /* check for valid point types */
 908         for(i = 0; i < cCount; i++) {
 909             switch(lpbTypes[i]) {
 910                 case PT_MOVETO:
 911                 case PT_LINETO | PT_CLOSEFIGURE:
 912                 case PT_LINETO:
 913                     break;
 914                 case PT_BEZIERTO:
 915                     if((i + 2 < cCount) && (lpbTypes[i + 1] == PT_BEZIERTO) &&
 916                         ((lpbTypes[i + 2] & ~PT_CLOSEFIGURE) == PT_BEZIERTO)){
 917                         i += 2;
 918                         break;
 919                     }
 920                 default:
 921                     goto end;
 922             }
 923         }
 924
 925         space = cCount + 300;
 926         line_pts = HeapAlloc(GetProcessHeap(), 0, space * sizeof(POINT));
 927         num_pts = 1;
 928
 929         line_pts[0].x = dc->CursPosX;
 930         line_pts[0].y = dc->CursPosY;
 931
 932         for(i = 0; i < cCount; i++) {
 933             switch(lpbTypes[i]) {
 934                 case PT_MOVETO:
 935                     if(num_pts >= 2)
 936                         Polyline(hdc, line_pts, num_pts);
 937                     num_pts = 0;
 938                     line_pts[num_pts++] = lppt[i];
 939                     break;
 940                 case PT_LINETO:
 941                 case (PT_LINETO | PT_CLOSEFIGURE):
 942                     line_pts[num_pts++] = lppt[i];
 943                     break;
 944                 case PT_BEZIERTO:
 945                     bzr[0].x = line_pts[num_pts - 1].x;
 946                     bzr[0].y = line_pts[num_pts - 1].y;
 947                     memcpy(&bzr[1], &lppt[i], 3 * sizeof(POINT));
 948
 949                     bzr_pts = GDI_Bezier(bzr, 4, &num_bzr_pts);
 950
 951                     size = num_pts + (cCount - i) + num_bzr_pts;
 952                     if(space < size){
 953                         space = size * 2;
 954                         line_pts = HeapReAlloc(GetProcessHeap(), 0, line_pts,
 955                             space * sizeof(POINT));
 956                     }
 957                     memcpy(&line_pts[num_pts], &bzr_pts[1],
 958                         (num_bzr_pts - 1) * sizeof(POINT));
 959                     num_pts += num_bzr_pts - 1;
 960                     HeapFree(GetProcessHeap(), 0, bzr_pts);
 961                     i += 2;
 962                     break;
 963                 default:
 964                     goto end;
 965             }
 966
 967             if(lpbTypes[i] & PT_CLOSEFIGURE)
 968                 line_pts[num_pts++] = line_pts[0];
 969         }
 970
 971         if(num_pts >= 2)
 972             Polyline(hdc, line_pts, num_pts);
 973
 974         MoveToEx(hdc, line_pts[num_pts - 1].x, line_pts[num_pts - 1].y, NULL);
 975         HeapFree(GetProcessHeap(), 0, line_pts);
 976         result = TRUE;
 977     }
 978
 979 end:
 980     release_dc_ptr( dc );
 981     return result;
 982 }
 983
 984
 985 /**********************************************************************
 986  *           LineDDA   (GDI32.@)
 987  */
 988 BOOL WINAPI LineDDA(INT nXStart, INT nYStart, INT nXEnd, INT nYEnd,
 989                     LINEDDAPROC callback, LPARAM lParam )
 990 {
 991     INT xadd = 1, yadd = 1;
 992     INT err,erradd;
 993     INT cnt;
 994     INT dx = nXEnd - nXStart;
 995     INT dy = nYEnd - nYStart;
 996
 997     if (dx < 0)
 998     {
 999         dx = -dx;
1000         xadd = -1;
1001     }
1002     if (dy < 0)
1003     {
1004         dy = -dy;
1005         yadd = -1;
1006     }
1007     if (dx > dy)  /* line is "more horizontal" */
1008     {
1009         err = 2*dy - dx; erradd = 2*dy - 2*dx;
1010         for(cnt = 0;cnt < dx; cnt++)
1011         {
1012             callback(nXStart,nYStart,lParam);
1013             if (err > 0)
1014             {
1015                 nYStart += yadd;
1016                 err += erradd;
1017             }
1018             else err += 2*dy;
1019             nXStart += xadd;
1020         }
1021     }
1022     else   /* line is "more vertical" */
1023     {
1024         err = 2*dx - dy; erradd = 2*dx - 2*dy;
1025         for(cnt = 0;cnt < dy; cnt++)
1026         {
1027             callback(nXStart,nYStart,lParam);
1028             if (err > 0)
1029             {
1030                 nXStart += xadd;
1031                 err += erradd;
1032             }
1033             else err += 2*dx;
1034             nYStart += yadd;
1035         }
1036     }
1037     return TRUE;
1038 }
1039
1040
1041 /******************************************************************
1042  *
1043  *   *Very* simple bezier drawing code,
1044  *
1045  *   It uses a recursive algorithm to divide the curve in a series
1046  *   of straight line segments. Not ideal but sufficient for me.
1047  *   If you are in need for something better look for some incremental
1048  *   algorithm.
1049  *
1050  *   7 July 1998 Rein Klazes
1051  */
1052
1053  /*
1054   * some macro definitions for bezier drawing
1055   *
1056   * to avoid truncation errors the coordinates are
1057   * shifted upwards. When used in drawing they are
1058   * shifted down again, including correct rounding
1059   * and avoiding floating point arithmetic
1060   * 4 bits should allow 27 bits coordinates which I saw
1061   * somewhere in the win32 doc's
1062   *
1063   */
1064
1065 #define BEZIERSHIFTBITS 4
1066 #define BEZIERSHIFTUP(x)    ((x)<<BEZIERSHIFTBITS)
1067 #define BEZIERPIXEL        BEZIERSHIFTUP(1)
1068 #define BEZIERSHIFTDOWN(x)  (((x)+(1<<(BEZIERSHIFTBITS-1)))>>BEZIERSHIFTBITS)
1069 /* maximum depth of recursion */
1070 #define BEZIERMAXDEPTH  8
1071
1072 /* size of array to store points on */
1073 /* enough for one curve */
1074 #define BEZIER_INITBUFSIZE    (150)
1075
1076 /* calculate Bezier average, in this case the middle
1077  * correctly rounded...
1078  * */
1079
1080 #define BEZIERMIDDLE(Mid, P1, P2) \
1081     (Mid).x=((P1).x+(P2).x + 1)/2;\
1082     (Mid).y=((P1).y+(P2).y + 1)/2;
1083
1084 /**********************************************************
1085 * BezierCheck helper function to check
1086 * that recursion can be terminated
1087 *       Points[0] and Points[3] are begin and endpoint
1088 *       Points[1] and Points[2] are control points
1089 *       level is the recursion depth
1090 *       returns true if the recursion can be terminated
1091 */
1092 static BOOL BezierCheck( int level, POINT *Points)
1093 {
1094     INT dx, dy;
1095     dx=Points[3].x-Points[0].x;
1096     dy=Points[3].y-Points[0].y;
1097     if(abs(dy)<=abs(dx)){/* shallow line */
1098         /* check that control points are between begin and end */
1099         if(Points[1].x < Points[0].x){
1100             if(Points[1].x < Points[3].x)
1101                 return FALSE;
1102         }else
1103             if(Points[1].x > Points[3].x)
1104                 return FALSE;
1105         if(Points[2].x < Points[0].x){
1106             if(Points[2].x < Points[3].x)
1107                 return FALSE;
1108         }else
1109             if(Points[2].x > Points[3].x)
1110                 return FALSE;
1111         dx=BEZIERSHIFTDOWN(dx);
1112         if(!dx) return TRUE;
1113         if(abs(Points[1].y-Points[0].y-(dy/dx)*
1114                 BEZIERSHIFTDOWN(Points[1].x-Points[0].x)) > BEZIERPIXEL ||
1115            abs(Points[2].y-Points[0].y-(dy/dx)*
1116                    BEZIERSHIFTDOWN(Points[2].x-Points[0].x)) > BEZIERPIXEL )
1117             return FALSE;
1118         else
1119             return TRUE;
1120     }else{ /* steep line */
1121         /* check that control points are between begin and end */
1122         if(Points[1].y < Points[0].y){
1123             if(Points[1].y < Points[3].y)
1124                 return FALSE;
1125         }else
1126             if(Points[1].y > Points[3].y)
1127                 return FALSE;
1128         if(Points[2].y < Points[0].y){
1129             if(Points[2].y < Points[3].y)
1130                 return FALSE;
1131         }else
1132             if(Points[2].y > Points[3].y)
1133                 return FALSE;
1134         dy=BEZIERSHIFTDOWN(dy);
1135         if(!dy) return TRUE;
1136         if(abs(Points[1].x-Points[0].x-(dx/dy)*
1137                 BEZIERSHIFTDOWN(Points[1].y-Points[0].y)) > BEZIERPIXEL ||
1138            abs(Points[2].x-Points[0].x-(dx/dy)*
1139                    BEZIERSHIFTDOWN(Points[2].y-Points[0].y)) > BEZIERPIXEL )
1140             return FALSE;
1141         else
1142             return TRUE;
1143     }
1144 }
1145
1146 /* Helper for GDI_Bezier.
1147  * Just handles one Bezier, so Points should point to four POINTs
1148  */
1149 static void GDI_InternalBezier( POINT *Points, POINT **PtsOut, INT *dwOut,
1150                                 INT *nPtsOut, INT level )
1151 {
1152     if(*nPtsOut == *dwOut) {
1153         *dwOut *= 2;
1154         *PtsOut = HeapReAlloc( GetProcessHeap(), 0, *PtsOut,
1155                                *dwOut * sizeof(POINT) );
1156     }
1157
1158     if(!level || BezierCheck(level, Points)) {
1159         if(*nPtsOut == 0) {
1160             (*PtsOut)[0].x = BEZIERSHIFTDOWN(Points[0].x);
1161             (*PtsOut)[0].y = BEZIERSHIFTDOWN(Points[0].y);
1162             *nPtsOut = 1;
1163         }
1164         (*PtsOut)[*nPtsOut].x = BEZIERSHIFTDOWN(Points[3].x);
1165         (*PtsOut)[*nPtsOut].y = BEZIERSHIFTDOWN(Points[3].y);
1166         (*nPtsOut) ++;
1167     } else {
1168         POINT Points2[4]; /* for the second recursive call */
1169         Points2[3]=Points[3];
1170         BEZIERMIDDLE(Points2[2], Points[2], Points[3]);
1171         BEZIERMIDDLE(Points2[0], Points[1], Points[2]);
1172         BEZIERMIDDLE(Points2[1],Points2[0],Points2[2]);
1173
1174         BEZIERMIDDLE(Points[1], Points[0],  Points[1]);
1175         BEZIERMIDDLE(Points[2], Points[1], Points2[0]);
1176         BEZIERMIDDLE(Points[3], Points[2], Points2[1]);
1177
1178         Points2[0]=Points[3];
1179
1180         /* do the two halves */
1181         GDI_InternalBezier(Points, PtsOut, dwOut, nPtsOut, level-1);
1182         GDI_InternalBezier(Points2, PtsOut, dwOut, nPtsOut, level-1);
1183     }
1184 }
1185
1186
1187
1188 /***********************************************************************
1189  *           GDI_Bezier   [INTERNAL]
1190  *   Calculate line segments that approximate -what microsoft calls- a bezier
1191  *   curve.
1192  *   The routine recursively divides the curve in two parts until a straight
1193  *   line can be drawn
1194  *
1195  *  PARAMS
1196  *
1197  *  Points  [I] Ptr to count POINTs which are the end and control points
1198  *              of the set of Bezier curves to flatten.
1199  *  count   [I] Number of Points.  Must be 3n+1.
1200  *  nPtsOut [O] Will contain no of points that have been produced (i.e. no. of
1201  *              lines+1).
1202  *
1203  *  RETURNS
1204  *
1205  *  Ptr to an array of POINTs that contain the lines that approximate the
1206  *  Beziers.  The array is allocated on the process heap and it is the caller's
1207  *  responsibility to HeapFree it. [this is not a particularly nice interface
1208  *  but since we can't know in advance how many points we will generate, the
1209  *  alternative would be to call the function twice, once to determine the size
1210  *  and a second time to do the work - I decided this was too much of a pain].
1211  */
1212 POINT *GDI_Bezier( const POINT *Points, INT count, INT *nPtsOut )
1213 {
1214     POINT *out;
1215     INT Bezier, dwOut = BEZIER_INITBUFSIZE, i;
1216
1217     if (count == 1 || (count - 1) % 3 != 0) {
1218         ERR("Invalid no. of points %d\n", count);
1219         return NULL;
1220     }
1221     *nPtsOut = 0;
1222     out = HeapAlloc( GetProcessHeap(), 0, dwOut * sizeof(POINT));
1223     for(Bezier = 0; Bezier < (count-1)/3; Bezier++) {
1224         POINT ptBuf[4];
1225         memcpy(ptBuf, Points + Bezier * 3, sizeof(POINT) * 4);
1226         for(i = 0; i < 4; i++) {
1227             ptBuf[i].x = BEZIERSHIFTUP(ptBuf[i].x);
1228             ptBuf[i].y = BEZIERSHIFTUP(ptBuf[i].y);
1229         }
1230         GDI_InternalBezier( ptBuf, &out, &dwOut, nPtsOut, BEZIERMAXDEPTH );
1231     }
1232     TRACE("Produced %d points\n", *nPtsOut);
1233     return out;
1234 }
1235
1236 /******************************************************************************
1237  *           GdiGradientFill   (GDI32.@)
1238  *
1239  *  FIXME: we don't support the Alpha channel properly
1240  */
1241 BOOL WINAPI GdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert,
1242                           void * grad_array, ULONG ngrad, ULONG mode )
1243 {
1244   unsigned int i;
1245
1246   TRACE("vert_array:%p nvert:%d grad_array:%p ngrad:%d\n",
1247         vert_array, nvert, grad_array, ngrad);
1248
1249   switch(mode)
1250     {
1251     case GRADIENT_FILL_RECT_H:
1252       for(i = 0; i < ngrad; i++)
1253         {
1254           GRADIENT_RECT *rect = ((GRADIENT_RECT *)grad_array) + i;
1255           TRIVERTEX *v1 = vert_array + rect->UpperLeft;
1256           TRIVERTEX *v2 = vert_array + rect->LowerRight;
1257           int y1 = v1->y < v2->y ? v1->y : v2->y;
1258           int y2 = v2->y > v1->y ? v2->y : v1->y;
1259           int x, dx;
1260           if (v1->x > v2->x)
1261             {
1262               TRIVERTEX *t = v2;
1263               v2 = v1;
1264               v1 = t;
1265             }
1266           dx = v2->x - v1->x;
1267           for (x = 0; x < dx; x++)
1268             {
1269               POINT pts[2];
1270               HPEN hPen, hOldPen;
1271
1272               hPen = CreatePen( PS_SOLID, 1, RGB(
1273                   (v1->Red   * (dx - x) + v2->Red   * x) / dx >> 8,
1274                   (v1->Green * (dx - x) + v2->Green * x) / dx >> 8,
1275                   (v1->Blue  * (dx - x) + v2->Blue  * x) / dx >> 8));
1276               hOldPen = SelectObject( hdc, hPen );
1277               pts[0].x = v1->x + x;
1278               pts[0].y = y1;
1279               pts[1].x = v1->x + x;
1280               pts[1].y = y2;
1281               Polyline( hdc, &pts[0], 2 );
1282               DeleteObject( SelectObject(hdc, hOldPen ) );
1283             }
1284         }
1285       break;
1286     case GRADIENT_FILL_RECT_V:
1287       for(i = 0; i < ngrad; i++)
1288         {
1289           GRADIENT_RECT *rect = ((GRADIENT_RECT *)grad_array) + i;
1290           TRIVERTEX *v1 = vert_array + rect->UpperLeft;
1291           TRIVERTEX *v2 = vert_array + rect->LowerRight;
1292           int x1 = v1->x < v2->x ? v1->x : v2->x;
1293           int x2 = v2->x > v1->x ? v2->x : v1->x;
1294           int y, dy;
1295           if (v1->y > v2->y)
1296             {
1297               TRIVERTEX *t = v2;
1298               v2 = v1;
1299               v1 = t;
1300             }
1301           dy = v2->y - v1->y;
1302           for (y = 0; y < dy; y++)
1303             {
1304               POINT pts[2];
1305               HPEN hPen, hOldPen;
1306
1307               hPen = CreatePen( PS_SOLID, 1, RGB(
1308                   (v1->Red   * (dy - y) + v2->Red   * y) / dy >> 8,
1309                   (v1->Green * (dy - y) + v2->Green * y) / dy >> 8,
1310                   (v1->Blue  * (dy - y) + v2->Blue  * y) / dy >> 8));
1311               hOldPen = SelectObject( hdc, hPen );
1312               pts[0].x = x1;
1313               pts[0].y = v1->y + y;
1314               pts[1].x = x2;
1315               pts[1].y = v1->y + y;
1316               Polyline( hdc, &pts[0], 2 );
1317               DeleteObject( SelectObject(hdc, hOldPen ) );
1318             }
1319         }
1320       break;
1321     case GRADIENT_FILL_TRIANGLE:
1322       for (i = 0; i < ngrad; i++)
1323         {
1324           GRADIENT_TRIANGLE *tri = ((GRADIENT_TRIANGLE *)grad_array) + i;
1325           TRIVERTEX *v1 = vert_array + tri->Vertex1;
1326           TRIVERTEX *v2 = vert_array + tri->Vertex2;
1327           TRIVERTEX *v3 = vert_array + tri->Vertex3;
1328           int y, dy;
1329
1330           if (v1->y > v2->y)
1331             { TRIVERTEX *t = v1; v1 = v2; v2 = t; }
1332           if (v2->y > v3->y)
1333             {
1334               TRIVERTEX *t = v2; v2 = v3; v3 = t;
1335               if (v1->y > v2->y)
1336                 { t = v1; v1 = v2; v2 = t; }
1337             }
1338           /* v1->y <= v2->y <= v3->y */
1339
1340           dy = v3->y - v1->y;
1341           for (y = 0; y < dy; y++)
1342             {
1343               /* v1->y <= y < v3->y */
1344               TRIVERTEX *v = y < (v2->y - v1->y) ? v1 : v3;
1345               /* (v->y <= y < v2->y) || (v2->y <= y < v->y) */
1346               int dy2 = v2->y - v->y;
1347               int y2 = y + v1->y - v->y;
1348
1349               int x1 = (v3->x     * y  + v1->x     * (dy  - y )) / dy;
1350               int x2 = (v2->x     * y2 + v-> x     * (dy2 - y2)) / dy2;
1351               int r1 = (v3->Red   * y  + v1->Red   * (dy  - y )) / dy;
1352               int r2 = (v2->Red   * y2 + v-> Red   * (dy2 - y2)) / dy2;
1353               int g1 = (v3->Green * y  + v1->Green * (dy  - y )) / dy;
1354               int g2 = (v2->Green * y2 + v-> Green * (dy2 - y2)) / dy2;
1355               int b1 = (v3->Blue  * y  + v1->Blue  * (dy  - y )) / dy;
1356               int b2 = (v2->Blue  * y2 + v-> Blue  * (dy2 - y2)) / dy2;
1357
1358               int x;
1359               if (x1 < x2)
1360                 {
1361                   int dx = x2 - x1;
1362                   for (x = 0; x < dx; x++)
1363                     SetPixel (hdc, x + x1, y + v1->y, RGB(
1364                       (r1 * (dx - x) + r2 * x) / dx >> 8,
1365                       (g1 * (dx - x) + g2 * x) / dx >> 8,
1366                       (b1 * (dx - x) + b2 * x) / dx >> 8));
1367                 }
1368               else
1369                 {
1370                   int dx = x1 - x2;
1371                   for (x = 0; x < dx; x++)
1372                     SetPixel (hdc, x + x2, y + v1->y, RGB(
1373                       (r2 * (dx - x) + r1 * x) / dx >> 8,
1374                       (g2 * (dx - x) + g1 * x) / dx >> 8,
1375                       (b2 * (dx - x) + b1 * x) / dx >> 8));
1376                 }
1377             }
1378         }
1379       break;
1380     default:
1381       return FALSE;
1382   }
1383
1384   return TRUE;
1385 }