comctl32/monthcal: Copy SYSTEMTIME with a simple assignment.
[wine] / 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 }