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