[WIN32K]
[reactos.git] / subsystems / win32 / win32k / objects / path.c
1 /*
2 * Graphics paths (BeginPath, EndPath etc.)
3 *
4 * Copyright 1997, 1998 Martin Boehme
5 * 1999 Huw D M Davies
6 * Copyright 2005 Dmitry Timoshkov
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 *
24 * Addaped for the use in ReactOS.
25 *
26 */
27 /*
28 * PROJECT: ReactOS win32 kernel mode subsystem
29 * LICENSE: GPL - See COPYING in the top level directory
30 * FILE: subsystems/win32/win32k/objects/path.c
31 * PURPOSE: Path support
32 * PROGRAMMER:
33 */
34
35 #include <w32k.h>
36 #include "math.h"
37
38 #define NDEBUG
39 #include <debug.h>
40
41 #define NUM_ENTRIES_INITIAL 16 /* Initial size of points / flags arrays */
42 #define GROW_FACTOR_NUMER 2 /* Numerator of grow factor for the array */
43 #define GROW_FACTOR_DENOM 1 /* Denominator of grow factor */
44
45 BOOL FASTCALL PATH_AddEntry (PPATH pPath, const POINT *pPoint, BYTE flags);
46 BOOL FASTCALL PATH_AddFlatBezier (PPATH pPath, POINT *pt, BOOL closed);
47 BOOL FASTCALL PATH_DoArcPart (PPATH pPath, FLOAT_POINT corners[], double angleStart, double angleEnd, BYTE startEntryType);
48 BOOL FASTCALL PATH_FillPath( PDC dc, PPATH pPath );
49 BOOL FASTCALL PATH_FlattenPath (PPATH pPath);
50 VOID FASTCALL PATH_NormalizePoint (FLOAT_POINT corners[], const FLOAT_POINT *pPoint, double *pX, double *pY);
51
52 BOOL FASTCALL PATH_ReserveEntries (PPATH pPath, INT numEntries);
53 VOID FASTCALL PATH_ScaleNormalizedPoint (FLOAT_POINT corners[], double x, double y, POINT *pPoint);
54 BOOL FASTCALL PATH_StrokePath(DC *dc, PPATH pPath);
55 BOOL PATH_CheckCorners(DC *dc, POINT corners[], INT x1, INT y1, INT x2, INT y2);
56
57 VOID FASTCALL IntGetCurrentPositionEx(PDC dc, LPPOINT pt);
58
59 /***********************************************************************
60 * Internal functions
61 */
62
63 BOOL
64 FASTCALL
65 PATH_Delete(HPATH hPath)
66 {
67 PPATH pPath;
68 if (!hPath) return FALSE;
69 pPath = PATH_LockPath( hPath );
70 if (!pPath) return FALSE;
71 PATH_DestroyGdiPath( pPath );
72 PATH_UnlockPath( pPath );
73 PATH_FreeExtPathByHandle(hPath);
74 return TRUE;
75 }
76
77
78 VOID
79 FASTCALL
80 IntGdiCloseFigure(PPATH pPath)
81 {
82 ASSERT(pPath->state == PATH_Open);
83
84 // FIXME: Shouldn't we draw a line to the beginning of the figure?
85 // Set PT_CLOSEFIGURE on the last entry and start a new stroke
86 if(pPath->numEntriesUsed)
87 {
88 pPath->pFlags[pPath->numEntriesUsed-1]|=PT_CLOSEFIGURE;
89 pPath->newStroke=TRUE;
90 }
91 }
92
93 /* PATH_FillPath
94 *
95 *
96 */
97 BOOL
98 FASTCALL
99 PATH_FillPath( PDC dc, PPATH pPath )
100 {
101 INT mapMode, graphicsMode;
102 SIZE ptViewportExt, ptWindowExt;
103 POINTL ptViewportOrg, ptWindowOrg;
104 XFORM xform;
105 HRGN hrgn;
106 PDC_ATTR pdcattr = dc->pdcattr;
107
108 if( pPath->state != PATH_Closed )
109 {
110 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
111 return FALSE;
112 }
113
114 if( PATH_PathToRegion( pPath, pdcattr->jFillMode, &hrgn ))
115 {
116 /* Since PaintRgn interprets the region as being in logical coordinates
117 * but the points we store for the path are already in device
118 * coordinates, we have to set the mapping mode to MM_TEXT temporarily.
119 * Using SaveDC to save information about the mapping mode / world
120 * transform would be easier but would require more overhead, especially
121 * now that SaveDC saves the current path.
122 */
123
124 /* Save the information about the old mapping mode */
125 mapMode = pdcattr->iMapMode;
126 ptViewportExt = pdcattr->szlViewportExt;
127 ptViewportOrg = pdcattr->ptlViewportOrg;
128 ptWindowExt = pdcattr->szlWindowExt;
129 ptWindowOrg = pdcattr->ptlWindowOrg;
130
131 /* Save world transform
132 * NB: The Windows documentation on world transforms would lead one to
133 * believe that this has to be done only in GM_ADVANCED; however, my
134 * tests show that resetting the graphics mode to GM_COMPATIBLE does
135 * not reset the world transform.
136 */
137 MatrixS2XForm(&xform, &dc->dclevel.mxWorldToPage);
138
139 /* Set MM_TEXT */
140 // IntGdiSetMapMode( dc, MM_TEXT );
141 // pdcattr->ptlViewportOrg.x = 0;
142 // pdcattr->ptlViewportOrg.y = 0;
143 // pdcattr->ptlWindowOrg.x = 0;
144 // pdcattr->ptlWindowOrg.y = 0;
145
146 graphicsMode = pdcattr->iGraphicsMode;
147 // pdcattr->iGraphicsMode = GM_ADVANCED;
148 // IntGdiModifyWorldTransform( dc, &xform, MWT_IDENTITY );
149 // pdcattr->iGraphicsMode = graphicsMode;
150
151 /* Paint the region */
152 IntGdiPaintRgn( dc, hrgn );
153 GreDeleteObject( hrgn );
154 /* Restore the old mapping mode */
155 // IntGdiSetMapMode( dc, mapMode );
156 // pdcattr->szlViewportExt = ptViewportExt;
157 // pdcattr->ptlViewportOrg = ptViewportOrg;
158 // pdcattr->szlWindowExt = ptWindowExt;
159 // pdcattr->ptlWindowOrg = ptWindowOrg;
160
161 /* Go to GM_ADVANCED temporarily to restore the world transform */
162 graphicsMode = pdcattr->iGraphicsMode;
163 // pdcattr->iGraphicsMode = GM_ADVANCED;
164 // IntGdiModifyWorldTransform( dc, &xform, MWT_MAX+1 );
165 // pdcattr->iGraphicsMode = graphicsMode;
166 return TRUE;
167 }
168 return FALSE;
169 }
170
171 /* PATH_InitGdiPath
172 *
173 * Initializes the GdiPath structure.
174 */
175 VOID
176 FASTCALL
177 PATH_InitGdiPath ( PPATH pPath )
178 {
179 ASSERT(pPath!=NULL);
180
181 pPath->state=PATH_Null;
182 pPath->pPoints=NULL;
183 pPath->pFlags=NULL;
184 pPath->numEntriesUsed=0;
185 pPath->numEntriesAllocated=0;
186 }
187
188 /* PATH_DestroyGdiPath
189 *
190 * Destroys a GdiPath structure (frees the memory in the arrays).
191 */
192 VOID
193 FASTCALL
194 PATH_DestroyGdiPath ( PPATH pPath )
195 {
196 ASSERT(pPath!=NULL);
197
198 if (pPath->pPoints) ExFreePoolWithTag(pPath->pPoints, TAG_PATH);
199 if (pPath->pFlags) ExFreePoolWithTag(pPath->pFlags, TAG_PATH);
200 }
201
202 /* PATH_AssignGdiPath
203 *
204 * Copies the GdiPath structure "pPathSrc" to "pPathDest". A deep copy is
205 * performed, i.e. the contents of the pPoints and pFlags arrays are copied,
206 * not just the pointers. Since this means that the arrays in pPathDest may
207 * need to be resized, pPathDest should have been initialized using
208 * PATH_InitGdiPath (in C++, this function would be an assignment operator,
209 * not a copy constructor).
210 * Returns TRUE if successful, else FALSE.
211 */
212 BOOL
213 FASTCALL
214 PATH_AssignGdiPath ( PPATH pPathDest, const PPATH pPathSrc )
215 {
216 ASSERT(pPathDest!=NULL && pPathSrc!=NULL);
217
218 /* Make sure destination arrays are big enough */
219 if ( !PATH_ReserveEntries(pPathDest, pPathSrc->numEntriesUsed) )
220 return FALSE;
221
222 /* Perform the copy operation */
223 memcpy(pPathDest->pPoints, pPathSrc->pPoints,
224 sizeof(POINT)*pPathSrc->numEntriesUsed);
225 memcpy(pPathDest->pFlags, pPathSrc->pFlags,
226 sizeof(BYTE)*pPathSrc->numEntriesUsed);
227
228 pPathDest->state=pPathSrc->state;
229 pPathDest->numEntriesUsed=pPathSrc->numEntriesUsed;
230 pPathDest->newStroke=pPathSrc->newStroke;
231 return TRUE;
232 }
233
234 /* PATH_MoveTo
235 *
236 * Should be called when a MoveTo is performed on a DC that has an
237 * open path. This starts a new stroke. Returns TRUE if successful, else
238 * FALSE.
239 */
240 BOOL
241 FASTCALL
242 PATH_MoveTo ( PDC dc )
243 {
244 PPATH pPath = PATH_LockPath( dc->dclevel.hPath );
245 if (!pPath) return FALSE;
246
247 /* Check that path is open */
248 if ( pPath->state != PATH_Open )
249 {
250 PATH_UnlockPath( pPath );
251 /* FIXME: Do we have to call SetLastError? */
252 return FALSE;
253 }
254 /* Start a new stroke */
255 pPath->newStroke = TRUE;
256 PATH_UnlockPath( pPath );
257 return TRUE;
258 }
259
260 /* PATH_LineTo
261 *
262 * Should be called when a LineTo is performed on a DC that has an
263 * open path. This adds a PT_LINETO entry to the path (and possibly
264 * a PT_MOVETO entry, if this is the first LineTo in a stroke).
265 * Returns TRUE if successful, else FALSE.
266 */
267 BOOL
268 FASTCALL
269 PATH_LineTo ( PDC dc, INT x, INT y )
270 {
271 BOOL Ret;
272 PPATH pPath;
273 POINT point, pointCurPos;
274
275 pPath = PATH_LockPath( dc->dclevel.hPath );
276 if (!pPath) return FALSE;
277
278 /* Check that path is open */
279 if ( pPath->state != PATH_Open )
280 {
281 PATH_UnlockPath( pPath );
282 return FALSE;
283 }
284
285 /* Convert point to device coordinates */
286 point.x=x;
287 point.y=y;
288 CoordLPtoDP ( dc, &point );
289
290 /* Add a PT_MOVETO if necessary */
291 if ( pPath->newStroke )
292 {
293 pPath->newStroke = FALSE;
294 IntGetCurrentPositionEx ( dc, &pointCurPos );
295 CoordLPtoDP ( dc, &pointCurPos );
296 if ( !PATH_AddEntry(pPath, &pointCurPos, PT_MOVETO) )
297 {
298 PATH_UnlockPath( pPath );
299 return FALSE;
300 }
301 }
302
303 /* Add a PT_LINETO entry */
304 Ret = PATH_AddEntry(pPath, &point, PT_LINETO);
305 PATH_UnlockPath( pPath );
306 return Ret;
307 }
308
309 /* PATH_Rectangle
310 *
311 * Should be called when a call to Rectangle is performed on a DC that has
312 * an open path. Returns TRUE if successful, else FALSE.
313 */
314 BOOL
315 FASTCALL
316 PATH_Rectangle ( PDC dc, INT x1, INT y1, INT x2, INT y2 )
317 {
318 PPATH pPath;
319 POINT corners[2], pointTemp;
320 INT temp;
321
322 pPath = PATH_LockPath( dc->dclevel.hPath );
323 if (!pPath) return FALSE;
324
325 /* Check that path is open */
326 if ( pPath->state != PATH_Open )
327 {
328 PATH_UnlockPath( pPath );
329 return FALSE;
330 }
331
332 /* Convert points to device coordinates */
333 corners[0].x=x1;
334 corners[0].y=y1;
335 corners[1].x=x2;
336 corners[1].y=y2;
337 IntLPtoDP ( dc, corners, 2 );
338
339 /* Make sure first corner is top left and second corner is bottom right */
340 if ( corners[0].x > corners[1].x )
341 {
342 temp=corners[0].x;
343 corners[0].x=corners[1].x;
344 corners[1].x=temp;
345 }
346 if ( corners[0].y > corners[1].y )
347 {
348 temp=corners[0].y;
349 corners[0].y=corners[1].y;
350 corners[1].y=temp;
351 }
352
353 /* In GM_COMPATIBLE, don't include bottom and right edges */
354 if (dc->pdcattr->iGraphicsMode == GM_COMPATIBLE)
355 {
356 corners[1].x--;
357 corners[1].y--;
358 }
359
360 /* Close any previous figure */
361 IntGdiCloseFigure(pPath);
362
363 /* Add four points to the path */
364 pointTemp.x=corners[1].x;
365 pointTemp.y=corners[0].y;
366 if ( !PATH_AddEntry(pPath, &pointTemp, PT_MOVETO) )
367 {
368 PATH_UnlockPath( pPath );
369 return FALSE;
370 }
371 if ( !PATH_AddEntry(pPath, corners, PT_LINETO) )
372 {
373 PATH_UnlockPath( pPath );
374 return FALSE;
375 }
376 pointTemp.x=corners[0].x;
377 pointTemp.y=corners[1].y;
378 if ( !PATH_AddEntry(pPath, &pointTemp, PT_LINETO) )
379 {
380 PATH_UnlockPath( pPath );
381 return FALSE;
382 }
383 if ( !PATH_AddEntry(pPath, corners+1, PT_LINETO) )
384 {
385 PATH_UnlockPath( pPath );
386 return FALSE;
387 }
388
389 /* Close the rectangle figure */
390 IntGdiCloseFigure(pPath) ;
391 PATH_UnlockPath( pPath );
392 return TRUE;
393 }
394
395 /* PATH_RoundRect
396 *
397 * Should be called when a call to RoundRect is performed on a DC that has
398 * an open path. Returns TRUE if successful, else FALSE.
399 *
400 * FIXME: it adds the same entries to the path as windows does, but there
401 * is an error in the bezier drawing code so that there are small pixel-size
402 * gaps when the resulting path is drawn by StrokePath()
403 */
404 BOOL FASTCALL PATH_RoundRect(DC *dc, INT x1, INT y1, INT x2, INT y2, INT ell_width, INT ell_height)
405 {
406 PPATH pPath;
407 POINT corners[2], pointTemp;
408 FLOAT_POINT ellCorners[2];
409
410 pPath = PATH_LockPath( dc->dclevel.hPath );
411 if (!pPath) return FALSE;
412
413 /* Check that path is open */
414 if(pPath->state!=PATH_Open)
415 {
416 PATH_UnlockPath( pPath );
417 return FALSE;
418 }
419
420 if(!PATH_CheckCorners(dc,corners,x1,y1,x2,y2))
421 {
422 PATH_UnlockPath( pPath );
423 return FALSE;
424 }
425
426 /* Add points to the roundrect path */
427 ellCorners[0].x = corners[1].x-ell_width;
428 ellCorners[0].y = corners[0].y;
429 ellCorners[1].x = corners[1].x;
430 ellCorners[1].y = corners[0].y+ell_height;
431 if(!PATH_DoArcPart(pPath, ellCorners, 0, -M_PI_2, PT_MOVETO))
432 {
433 PATH_UnlockPath( pPath );
434 return FALSE;
435 }
436 pointTemp.x = corners[0].x+ell_width/2;
437 pointTemp.y = corners[0].y;
438 if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
439 {
440 PATH_UnlockPath( pPath );
441 return FALSE;
442 }
443 ellCorners[0].x = corners[0].x;
444 ellCorners[1].x = corners[0].x+ell_width;
445 if(!PATH_DoArcPart(pPath, ellCorners, -M_PI_2, -M_PI, FALSE))
446 {
447 PATH_UnlockPath( pPath );
448 return FALSE;
449 }
450 pointTemp.x = corners[0].x;
451 pointTemp.y = corners[1].y-ell_height/2;
452 if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
453 {
454 PATH_UnlockPath( pPath );
455 return FALSE;
456 }
457 ellCorners[0].y = corners[1].y-ell_height;
458 ellCorners[1].y = corners[1].y;
459 if(!PATH_DoArcPart(pPath, ellCorners, M_PI, M_PI_2, FALSE))
460 {
461 PATH_UnlockPath( pPath );
462 return FALSE;
463 }
464 pointTemp.x = corners[1].x-ell_width/2;
465 pointTemp.y = corners[1].y;
466 if(!PATH_AddEntry(pPath, &pointTemp, PT_LINETO))
467 {
468 PATH_UnlockPath( pPath );
469 return FALSE;
470 }
471 ellCorners[0].x = corners[1].x-ell_width;
472 ellCorners[1].x = corners[1].x;
473 if(!PATH_DoArcPart(pPath, ellCorners, M_PI_2, 0, FALSE))
474 {
475 PATH_UnlockPath( pPath );
476 return FALSE;
477 }
478
479 IntGdiCloseFigure(pPath);
480 PATH_UnlockPath( pPath );
481 return TRUE;
482 }
483
484 /* PATH_Ellipse
485 *
486 * Should be called when a call to Ellipse is performed on a DC that has
487 * an open path. This adds four Bezier splines representing the ellipse
488 * to the path. Returns TRUE if successful, else FALSE.
489 */
490 BOOL
491 FASTCALL
492 PATH_Ellipse ( PDC dc, INT x1, INT y1, INT x2, INT y2 )
493 {
494 PPATH pPath;
495 /* TODO: This should probably be revised to call PATH_AngleArc */
496 /* (once it exists) */
497 BOOL Ret = PATH_Arc ( dc, x1, y1, x2, y2, x1, (y1+y2)/2, x1, (y1+y2)/2, GdiTypeArc );
498 if (Ret)
499 {
500 pPath = PATH_LockPath( dc->dclevel.hPath );
501 if (!pPath) return FALSE;
502 IntGdiCloseFigure(pPath);
503 PATH_UnlockPath( pPath );
504 }
505 return Ret;
506 }
507
508 /* PATH_Arc
509 *
510 * Should be called when a call to Arc is performed on a DC that has
511 * an open path. This adds up to five Bezier splines representing the arc
512 * to the path. When 'lines' is 1, we add 1 extra line to get a chord,
513 * when 'lines' is 2, we add 2 extra lines to get a pie, and when 'lines' is
514 * -1 we add 1 extra line from the current DC position to the starting position
515 * of the arc before drawing the arc itself (arcto). Returns TRUE if successful,
516 * else FALSE.
517 */
518 BOOL
519 FASTCALL
520 PATH_Arc ( PDC dc, INT x1, INT y1, INT x2, INT y2,
521 INT xStart, INT yStart, INT xEnd, INT yEnd, INT lines)
522 {
523 double angleStart, angleEnd, angleStartQuadrant, angleEndQuadrant=0.0;
524 /* Initialize angleEndQuadrant to silence gcc's warning */
525 double x, y;
526 FLOAT_POINT corners[2], pointStart, pointEnd;
527 POINT centre, pointCurPos;
528 BOOL start, end, Ret = TRUE;
529 INT temp;
530 BOOL clockwise;
531 PPATH pPath;
532
533 /* FIXME: This function should check for all possible error returns */
534 /* FIXME: Do we have to respect newStroke? */
535
536 ASSERT ( dc );
537
538 pPath = PATH_LockPath( dc->dclevel.hPath );
539 if (!pPath) return FALSE;
540
541 clockwise = ((dc->dclevel.flPath & DCPATH_CLOCKWISE) != 0);
542
543 /* Check that path is open */
544 if ( pPath->state != PATH_Open )
545 {
546 Ret = FALSE;
547 goto ArcExit;
548 }
549
550 /* Check for zero height / width */
551 /* FIXME: Only in GM_COMPATIBLE? */
552 if ( x1==x2 || y1==y2 )
553 {
554 Ret = TRUE;
555 goto ArcExit;
556 }
557 /* Convert points to device coordinates */
558 corners[0].x=(FLOAT)x1;
559 corners[0].y=(FLOAT)y1;
560 corners[1].x=(FLOAT)x2;
561 corners[1].y=(FLOAT)y2;
562 pointStart.x=(FLOAT)xStart;
563 pointStart.y=(FLOAT)yStart;
564 pointEnd.x=(FLOAT)xEnd;
565 pointEnd.y=(FLOAT)yEnd;
566 INTERNAL_LPTODP_FLOAT(dc, corners);
567 INTERNAL_LPTODP_FLOAT(dc, corners+1);
568 INTERNAL_LPTODP_FLOAT(dc, &pointStart);
569 INTERNAL_LPTODP_FLOAT(dc, &pointEnd);
570
571 /* Make sure first corner is top left and second corner is bottom right */
572 if ( corners[0].x > corners[1].x )
573 {
574 temp=corners[0].x;
575 corners[0].x=corners[1].x;
576 corners[1].x=temp;
577 }
578 if ( corners[0].y > corners[1].y )
579 {
580 temp=corners[0].y;
581 corners[0].y=corners[1].y;
582 corners[1].y=temp;
583 }
584
585 /* Compute start and end angle */
586 PATH_NormalizePoint(corners, &pointStart, &x, &y);
587 angleStart=atan2(y, x);
588 PATH_NormalizePoint(corners, &pointEnd, &x, &y);
589 angleEnd=atan2(y, x);
590
591 /* Make sure the end angle is "on the right side" of the start angle */
592 if ( clockwise )
593 {
594 if ( angleEnd <= angleStart )
595 {
596 angleEnd+=2*M_PI;
597 ASSERT(angleEnd>=angleStart);
598 }
599 }
600 else
601 {
602 if(angleEnd>=angleStart)
603 {
604 angleEnd-=2*M_PI;
605 ASSERT(angleEnd<=angleStart);
606 }
607 }
608
609 /* In GM_COMPATIBLE, don't include bottom and right edges */
610 if (dc->pdcattr->iGraphicsMode == GM_COMPATIBLE )
611 {
612 corners[1].x--;
613 corners[1].y--;
614 }
615
616 /* arcto: Add a PT_MOVETO only if this is the first entry in a stroke */
617 if(lines==GdiTypeArcTo && pPath->newStroke) // -1
618 {
619 pPath->newStroke=FALSE;
620 IntGetCurrentPositionEx ( dc, &pointCurPos );
621 CoordLPtoDP(dc, &pointCurPos);
622 if(!PATH_AddEntry(pPath, &pointCurPos, PT_MOVETO))
623 {
624 Ret = FALSE;
625 goto ArcExit;
626 }
627 }
628
629 /* Add the arc to the path with one Bezier spline per quadrant that the
630 * arc spans */
631 start=TRUE;
632 end=FALSE;
633 do
634 {
635 /* Determine the start and end angles for this quadrant */
636 if(start)
637 {
638 angleStartQuadrant=angleStart;
639 if ( clockwise )
640 angleEndQuadrant=(floor(angleStart/M_PI_2)+1.0)*M_PI_2;
641 else
642 angleEndQuadrant=(ceil(angleStart/M_PI_2)-1.0)*M_PI_2;
643 }
644 else
645 {
646 angleStartQuadrant=angleEndQuadrant;
647 if ( clockwise )
648 angleEndQuadrant+=M_PI_2;
649 else
650 angleEndQuadrant-=M_PI_2;
651 }
652
653 /* Have we reached the last part of the arc? */
654 if ( (clockwise && angleEnd<angleEndQuadrant)
655 || (!clockwise && angleEnd>angleEndQuadrant)
656 )
657 {
658 /* Adjust the end angle for this quadrant */
659 angleEndQuadrant = angleEnd;
660 end = TRUE;
661 }
662
663 /* Add the Bezier spline to the path */
664 PATH_DoArcPart ( pPath, corners, angleStartQuadrant, angleEndQuadrant,
665 start ? (lines==GdiTypeArcTo ? PT_LINETO : PT_MOVETO) : FALSE ); // -1
666 start = FALSE;
667 } while(!end);
668
669 /* chord: close figure. pie: add line and close figure */
670 if (lines==GdiTypeChord) // 1
671 {
672 IntGdiCloseFigure(pPath);
673 }
674 else if (lines==GdiTypePie) // 2
675 {
676 centre.x = (corners[0].x+corners[1].x)/2;
677 centre.y = (corners[0].y+corners[1].y)/2;
678 if(!PATH_AddEntry(pPath, &centre, PT_LINETO | PT_CLOSEFIGURE))
679 Ret = FALSE;
680 }
681 ArcExit:
682 PATH_UnlockPath( pPath );
683 return Ret;
684 }
685
686 BOOL
687 FASTCALL
688 PATH_PolyBezierTo ( PDC dc, const POINT *pts, DWORD cbPoints )
689 {
690 POINT pt;
691 ULONG i;
692 PPATH pPath;
693
694 ASSERT ( dc );
695 ASSERT ( pts );
696 ASSERT ( cbPoints );
697
698 pPath = PATH_LockPath( dc->dclevel.hPath );
699 if (!pPath) return FALSE;
700
701 /* Check that path is open */
702 if ( pPath->state != PATH_Open )
703 {
704 PATH_UnlockPath( pPath );
705 return FALSE;
706 }
707
708 /* Add a PT_MOVETO if necessary */
709 if ( pPath->newStroke )
710 {
711 pPath->newStroke=FALSE;
712 IntGetCurrentPositionEx ( dc, &pt );
713 CoordLPtoDP ( dc, &pt );
714 if ( !PATH_AddEntry(pPath, &pt, PT_MOVETO) )
715 {
716 PATH_UnlockPath( pPath );
717 return FALSE;
718 }
719 }
720
721 for(i = 0; i < cbPoints; i++)
722 {
723 pt = pts[i];
724 CoordLPtoDP ( dc, &pt );
725 PATH_AddEntry(pPath, &pt, PT_BEZIERTO);
726 }
727 PATH_UnlockPath( pPath );
728 return TRUE;
729 }
730
731 BOOL
732 FASTCALL
733 PATH_PolyBezier ( PDC dc, const POINT *pts, DWORD cbPoints )
734 {
735 POINT pt;
736 ULONG i;
737 PPATH pPath;
738
739 ASSERT ( dc );
740 ASSERT ( pts );
741 ASSERT ( cbPoints );
742
743 pPath = PATH_LockPath( dc->dclevel.hPath );
744 if (!pPath) return FALSE;
745
746 /* Check that path is open */
747 if ( pPath->state != PATH_Open )
748 {
749 PATH_UnlockPath( pPath );
750 return FALSE;
751 }
752
753 for ( i = 0; i < cbPoints; i++ )
754 {
755 pt = pts[i];
756 CoordLPtoDP ( dc, &pt );
757 PATH_AddEntry ( pPath, &pt, (i == 0) ? PT_MOVETO : PT_BEZIERTO );
758 }
759 PATH_UnlockPath( pPath );
760 return TRUE;
761 }
762
763 BOOL
764 FASTCALL
765 PATH_Polyline ( PDC dc, const POINT *pts, DWORD cbPoints )
766 {
767 POINT pt;
768 ULONG i;
769 PPATH pPath;
770
771 ASSERT ( dc );
772 ASSERT ( pts );
773 ASSERT ( cbPoints );
774
775 pPath = PATH_LockPath( dc->dclevel.hPath );
776 if (!pPath) return FALSE;
777
778 /* Check that path is open */
779 if ( pPath->state != PATH_Open )
780 {
781 PATH_UnlockPath( pPath );
782 return FALSE;
783 }
784 for ( i = 0; i < cbPoints; i++ )
785 {
786 pt = pts[i];
787 CoordLPtoDP ( dc, &pt );
788 PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO : PT_LINETO);
789 }
790 PATH_UnlockPath( pPath );
791 return TRUE;
792 }
793
794 BOOL
795 FASTCALL
796 PATH_PolylineTo ( PDC dc, const POINT *pts, DWORD cbPoints )
797 {
798 POINT pt;
799 ULONG i;
800 PPATH pPath;
801
802 ASSERT ( dc );
803 ASSERT ( pts );
804 ASSERT ( cbPoints );
805
806 pPath = PATH_LockPath( dc->dclevel.hPath );
807 if (!pPath) return FALSE;
808
809 /* Check that path is open */
810 if ( pPath->state != PATH_Open )
811 {
812 PATH_UnlockPath( pPath );
813 return FALSE;
814 }
815
816 /* Add a PT_MOVETO if necessary */
817 if ( pPath->newStroke )
818 {
819 pPath->newStroke = FALSE;
820 IntGetCurrentPositionEx ( dc, &pt );
821 CoordLPtoDP ( dc, &pt );
822 if ( !PATH_AddEntry(pPath, &pt, PT_MOVETO) )
823 {
824 PATH_UnlockPath( pPath );
825 return FALSE;
826 }
827 }
828
829 for(i = 0; i < cbPoints; i++)
830 {
831 pt = pts[i];
832 CoordLPtoDP ( dc, &pt );
833 PATH_AddEntry(pPath, &pt, PT_LINETO);
834 }
835 PATH_UnlockPath( pPath );
836 return TRUE;
837 }
838
839
840 BOOL
841 FASTCALL
842 PATH_Polygon ( PDC dc, const POINT *pts, DWORD cbPoints )
843 {
844 POINT pt;
845 ULONG i;
846 PPATH pPath;
847
848 ASSERT ( dc );
849 ASSERT ( pts );
850
851 pPath = PATH_LockPath( dc->dclevel.hPath );
852 if (!pPath) return FALSE;
853
854 /* Check that path is open */
855 if ( pPath->state != PATH_Open )
856 {
857 PATH_UnlockPath( pPath );
858 return FALSE;
859 }
860
861 for(i = 0; i < cbPoints; i++)
862 {
863 pt = pts[i];
864 CoordLPtoDP ( dc, &pt );
865 PATH_AddEntry(pPath, &pt, (i == 0) ? PT_MOVETO :
866 ((i == cbPoints-1) ? PT_LINETO | PT_CLOSEFIGURE :
867 PT_LINETO));
868 }
869 PATH_UnlockPath( pPath );
870 return TRUE;
871 }
872
873 BOOL
874 FASTCALL
875 PATH_PolyPolygon ( PDC dc, const POINT* pts, const INT* counts, UINT polygons )
876 {
877 POINT pt, startpt;
878 ULONG poly, point, i;
879 PPATH pPath;
880
881 ASSERT ( dc );
882 ASSERT ( pts );
883 ASSERT ( counts );
884 ASSERT ( polygons );
885
886 pPath = PATH_LockPath( dc->dclevel.hPath );
887 if (!pPath) return FALSE;
888
889 /* Check that path is open */
890 if ( pPath->state != PATH_Open )
891 {
892 PATH_UnlockPath( pPath );
893 return FALSE;
894 }
895
896 for(i = 0, poly = 0; poly < polygons; poly++)
897 {
898 for(point = 0; point < (ULONG) counts[poly]; point++, i++)
899 {
900 pt = pts[i];
901 CoordLPtoDP ( dc, &pt );
902 if(point == 0) startpt = pt;
903 PATH_AddEntry(pPath, &pt, (point == 0) ? PT_MOVETO : PT_LINETO);
904 }
905 /* win98 adds an extra line to close the figure for some reason */
906 PATH_AddEntry(pPath, &startpt, PT_LINETO | PT_CLOSEFIGURE);
907 }
908 PATH_UnlockPath( pPath );
909 return TRUE;
910 }
911
912 BOOL
913 FASTCALL
914 PATH_PolyPolyline ( PDC dc, const POINT* pts, const DWORD* counts, DWORD polylines )
915 {
916 POINT pt;
917 ULONG poly, point, i;
918 PPATH pPath;
919
920 ASSERT ( dc );
921 ASSERT ( pts );
922 ASSERT ( counts );
923 ASSERT ( polylines );
924
925 pPath = PATH_LockPath( dc->dclevel.hPath );
926 if (!pPath) return FALSE;
927
928 /* Check that path is open */
929 if ( pPath->state != PATH_Open )
930 {
931 PATH_UnlockPath( pPath );
932 return FALSE;
933 }
934
935 for(i = 0, poly = 0; poly < polylines; poly++)
936 {
937 for(point = 0; point < counts[poly]; point++, i++)
938 {
939 pt = pts[i];
940 CoordLPtoDP ( dc, &pt );
941 PATH_AddEntry(pPath, &pt, (point == 0) ? PT_MOVETO : PT_LINETO);
942 }
943 }
944 PATH_UnlockPath( pPath );
945 return TRUE;
946 }
947
948
949 /* PATH_CheckCorners
950 *
951 * Helper function for PATH_RoundRect() and PATH_Rectangle()
952 */
953 BOOL PATH_CheckCorners(DC *dc, POINT corners[], INT x1, INT y1, INT x2, INT y2)
954 {
955 INT temp;
956 PDC_ATTR pdcattr = dc->pdcattr;
957
958 /* Convert points to device coordinates */
959 corners[0].x=x1;
960 corners[0].y=y1;
961 corners[1].x=x2;
962 corners[1].y=y2;
963 CoordLPtoDP(dc, &corners[0]);
964 CoordLPtoDP(dc, &corners[1]);
965
966 /* Make sure first corner is top left and second corner is bottom right */
967 if(corners[0].x>corners[1].x)
968 {
969 temp=corners[0].x;
970 corners[0].x=corners[1].x;
971 corners[1].x=temp;
972 }
973 if(corners[0].y>corners[1].y)
974 {
975 temp=corners[0].y;
976 corners[0].y=corners[1].y;
977 corners[1].y=temp;
978 }
979
980 /* In GM_COMPATIBLE, don't include bottom and right edges */
981 if(pdcattr->iGraphicsMode==GM_COMPATIBLE)
982 {
983 corners[1].x--;
984 corners[1].y--;
985 }
986
987 return TRUE;
988 }
989
990
991 /* PATH_AddFlatBezier
992 *
993 */
994 BOOL
995 FASTCALL
996 PATH_AddFlatBezier ( PPATH pPath, POINT *pt, BOOL closed )
997 {
998 POINT *pts;
999 INT no, i;
1000
1001 pts = GDI_Bezier( pt, 4, &no );
1002 if ( !pts ) return FALSE;
1003
1004 for(i = 1; i < no; i++)
1005 PATH_AddEntry(pPath, &pts[i], (i == no-1 && closed) ? PT_LINETO | PT_CLOSEFIGURE : PT_LINETO);
1006
1007 ExFreePoolWithTag(pts, TAG_BEZIER);
1008 return TRUE;
1009 }
1010
1011 /* PATH_FlattenPath
1012 *
1013 * Replaces Beziers with line segments
1014 *
1015 */
1016 BOOL
1017 FASTCALL
1018 PATH_FlattenPath(PPATH pPath)
1019 {
1020 PATH newPath;
1021 INT srcpt;
1022
1023 RtlZeroMemory(&newPath, sizeof(newPath));
1024 newPath.state = PATH_Open;
1025 for(srcpt = 0; srcpt < pPath->numEntriesUsed; srcpt++) {
1026 switch(pPath->pFlags[srcpt] & ~PT_CLOSEFIGURE) {
1027 case PT_MOVETO:
1028 case PT_LINETO:
1029 PATH_AddEntry(&newPath, &pPath->pPoints[srcpt], pPath->pFlags[srcpt]);
1030 break;
1031 case PT_BEZIERTO:
1032 PATH_AddFlatBezier(&newPath, &pPath->pPoints[srcpt-1], pPath->pFlags[srcpt+2] & PT_CLOSEFIGURE);
1033 srcpt += 2;
1034 break;
1035 }
1036 }
1037 newPath.state = PATH_Closed;
1038 PATH_AssignGdiPath(pPath, &newPath);
1039 PATH_EmptyPath(&newPath);
1040 return TRUE;
1041 }
1042
1043
1044 /* PATH_PathToRegion
1045 *
1046 * Creates a region from the specified path using the specified polygon
1047 * filling mode. The path is left unchanged. A handle to the region that
1048 * was created is stored in *pHrgn. If successful, TRUE is returned; if an
1049 * error occurs, SetLastError is called with the appropriate value and
1050 * FALSE is returned.
1051 */
1052 BOOL
1053 FASTCALL
1054 PATH_PathToRegion ( PPATH pPath, INT nPolyFillMode, HRGN *pHrgn )
1055 {
1056 int numStrokes, iStroke, i;
1057 PULONG pNumPointsInStroke;
1058 HRGN hrgn = 0;
1059
1060 ASSERT(pPath!=NULL);
1061 ASSERT(pHrgn!=NULL);
1062
1063 PATH_FlattenPath ( pPath );
1064
1065 /* FIXME: What happens when number of points is zero? */
1066
1067 /* First pass: Find out how many strokes there are in the path */
1068 /* FIXME: We could eliminate this with some bookkeeping in GdiPath */
1069 numStrokes=0;
1070 for(i=0; i<pPath->numEntriesUsed; i++)
1071 if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
1072 numStrokes++;
1073
1074 /* Allocate memory for number-of-points-in-stroke array */
1075 pNumPointsInStroke = ExAllocatePoolWithTag(PagedPool, sizeof(ULONG) * numStrokes, TAG_PATH);
1076 if(!pNumPointsInStroke)
1077 {
1078 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1079 return FALSE;
1080 }
1081
1082 /* Second pass: remember number of points in each polygon */
1083 iStroke=-1; /* Will get incremented to 0 at beginning of first stroke */
1084 for(i=0; i<pPath->numEntriesUsed; i++)
1085 {
1086 /* Is this the beginning of a new stroke? */
1087 if((pPath->pFlags[i] & ~PT_CLOSEFIGURE) == PT_MOVETO)
1088 {
1089 iStroke++;
1090 pNumPointsInStroke[iStroke]=0;
1091 }
1092
1093 pNumPointsInStroke[iStroke]++;
1094 }
1095
1096 /* Create a region from the strokes */
1097 hrgn = IntCreatePolyPolygonRgn( pPath->pPoints,
1098 pNumPointsInStroke,
1099 numStrokes,
1100 nPolyFillMode);
1101 if(hrgn==(HRGN)0)
1102 {
1103 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1104 return FALSE;
1105 }
1106
1107 /* Free memory for number-of-points-in-stroke array */
1108 ExFreePoolWithTag(pNumPointsInStroke, TAG_PATH);
1109
1110 /* Success! */
1111 *pHrgn=hrgn;
1112 return TRUE;
1113 }
1114
1115 /* PATH_EmptyPath
1116 *
1117 * Removes all entries from the path and sets the path state to PATH_Null.
1118 */
1119 VOID
1120 FASTCALL
1121 PATH_EmptyPath ( PPATH pPath )
1122 {
1123 ASSERT(pPath!=NULL);
1124
1125 pPath->state=PATH_Null;
1126 pPath->numEntriesUsed=0;
1127 }
1128
1129 /* PATH_AddEntry
1130 *
1131 * Adds an entry to the path. For "flags", pass either PT_MOVETO, PT_LINETO
1132 * or PT_BEZIERTO, optionally ORed with PT_CLOSEFIGURE. Returns TRUE if
1133 * successful, FALSE otherwise (e.g. if not enough memory was available).
1134 */
1135 BOOL
1136 FASTCALL
1137 PATH_AddEntry ( PPATH pPath, const POINT *pPoint, BYTE flags )
1138 {
1139 ASSERT(pPath!=NULL);
1140
1141 /* FIXME: If newStroke is true, perhaps we want to check that we're
1142 * getting a PT_MOVETO
1143 */
1144
1145 /* Check that path is open */
1146 if ( pPath->state != PATH_Open )
1147 return FALSE;
1148
1149 /* Reserve enough memory for an extra path entry */
1150 if ( !PATH_ReserveEntries(pPath, pPath->numEntriesUsed+1) )
1151 return FALSE;
1152
1153 /* Store information in path entry */
1154 pPath->pPoints[pPath->numEntriesUsed]=*pPoint;
1155 pPath->pFlags[pPath->numEntriesUsed]=flags;
1156
1157 /* If this is PT_CLOSEFIGURE, we have to start a new stroke next time */
1158 if((flags & PT_CLOSEFIGURE) == PT_CLOSEFIGURE)
1159 pPath->newStroke=TRUE;
1160
1161 /* Increment entry count */
1162 pPath->numEntriesUsed++;
1163
1164 return TRUE;
1165 }
1166
1167 /* PATH_ReserveEntries
1168 *
1169 * Ensures that at least "numEntries" entries (for points and flags) have
1170 * been allocated; allocates larger arrays and copies the existing entries
1171 * to those arrays, if necessary. Returns TRUE if successful, else FALSE.
1172 */
1173 BOOL
1174 FASTCALL
1175 PATH_ReserveEntries ( PPATH pPath, INT numEntries )
1176 {
1177 INT numEntriesToAllocate;
1178 POINT *pPointsNew;
1179 BYTE *pFlagsNew;
1180
1181 ASSERT(pPath!=NULL);
1182 ASSERT(numEntries>=0);
1183
1184 /* Do we have to allocate more memory? */
1185 if(numEntries > pPath->numEntriesAllocated)
1186 {
1187 /* Find number of entries to allocate. We let the size of the array
1188 * grow exponentially, since that will guarantee linear time
1189 * complexity. */
1190 if(pPath->numEntriesAllocated)
1191 {
1192 numEntriesToAllocate=pPath->numEntriesAllocated;
1193 while(numEntriesToAllocate<numEntries)
1194 numEntriesToAllocate=numEntriesToAllocate*GROW_FACTOR_NUMER/GROW_FACTOR_DENOM;
1195 } else
1196 numEntriesToAllocate=numEntries;
1197
1198 /* Allocate new arrays */
1199 pPointsNew=(POINT *)ExAllocatePoolWithTag(PagedPool, numEntriesToAllocate * sizeof(POINT), TAG_PATH);
1200 if(!pPointsNew)
1201 return FALSE;
1202 pFlagsNew=(BYTE *)ExAllocatePoolWithTag(PagedPool, numEntriesToAllocate * sizeof(BYTE), TAG_PATH);
1203 if(!pFlagsNew)
1204 {
1205 ExFreePoolWithTag(pPointsNew, TAG_PATH);
1206 return FALSE;
1207 }
1208
1209 /* Copy old arrays to new arrays and discard old arrays */
1210 if(pPath->pPoints)
1211 {
1212 ASSERT(pPath->pFlags);
1213
1214 memcpy(pPointsNew, pPath->pPoints, sizeof(POINT)*pPath->numEntriesUsed);
1215 memcpy(pFlagsNew, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
1216
1217 ExFreePoolWithTag(pPath->pPoints, TAG_PATH);
1218 ExFreePoolWithTag(pPath->pFlags, TAG_PATH);
1219 }
1220 pPath->pPoints=pPointsNew;
1221 pPath->pFlags=pFlagsNew;
1222 pPath->numEntriesAllocated=numEntriesToAllocate;
1223 }
1224
1225 return TRUE;
1226 }
1227
1228 /* PATH_DoArcPart
1229 *
1230 * Creates a Bezier spline that corresponds to part of an arc and appends the
1231 * corresponding points to the path. The start and end angles are passed in
1232 * "angleStart" and "angleEnd"; these angles should span a quarter circle
1233 * at most. If "startEntryType" is non-zero, an entry of that type for the first
1234 * control point is added to the path; otherwise, it is assumed that the current
1235 * position is equal to the first control point.
1236 */
1237 BOOL
1238 FASTCALL
1239 PATH_DoArcPart ( PPATH pPath, FLOAT_POINT corners[],
1240 double angleStart, double angleEnd, BYTE startEntryType )
1241 {
1242 double halfAngle, a;
1243 double xNorm[4], yNorm[4];
1244 POINT point;
1245 int i;
1246
1247 ASSERT(fabs(angleEnd-angleStart)<=M_PI_2);
1248
1249 /* FIXME: Is there an easier way of computing this? */
1250
1251 /* Compute control points */
1252 halfAngle=(angleEnd-angleStart)/2.0;
1253 if(fabs(halfAngle)>1e-8)
1254 {
1255 a=4.0/3.0*(1-cos(halfAngle))/sin(halfAngle);
1256 xNorm[0]=cos(angleStart);
1257 yNorm[0]=sin(angleStart);
1258 xNorm[1]=xNorm[0] - a*yNorm[0];
1259 yNorm[1]=yNorm[0] + a*xNorm[0];
1260 xNorm[3]=cos(angleEnd);
1261 yNorm[3]=sin(angleEnd);
1262 xNorm[2]=xNorm[3] + a*yNorm[3];
1263 yNorm[2]=yNorm[3] - a*xNorm[3];
1264 } else
1265 for(i=0; i<4; i++)
1266 {
1267 xNorm[i]=cos(angleStart);
1268 yNorm[i]=sin(angleStart);
1269 }
1270
1271 /* Add starting point to path if desired */
1272 if(startEntryType)
1273 {
1274 PATH_ScaleNormalizedPoint(corners, xNorm[0], yNorm[0], &point);
1275 if(!PATH_AddEntry(pPath, &point, startEntryType))
1276 return FALSE;
1277 }
1278
1279 /* Add remaining control points */
1280 for(i=1; i<4; i++)
1281 {
1282 PATH_ScaleNormalizedPoint(corners, xNorm[i], yNorm[i], &point);
1283 if(!PATH_AddEntry(pPath, &point, PT_BEZIERTO))
1284 return FALSE;
1285 }
1286
1287 return TRUE;
1288 }
1289
1290 /* PATH_ScaleNormalizedPoint
1291 *
1292 * Scales a normalized point (x, y) with respect to the box whose corners are
1293 * passed in "corners". The point is stored in "*pPoint". The normalized
1294 * coordinates (-1.0, -1.0) correspond to corners[0], the coordinates
1295 * (1.0, 1.0) correspond to corners[1].
1296 */
1297 VOID
1298 FASTCALL
1299 PATH_ScaleNormalizedPoint ( FLOAT_POINT corners[], double x,
1300 double y, POINT *pPoint )
1301 {
1302 ASSERT ( corners );
1303 ASSERT ( pPoint );
1304 pPoint->x=GDI_ROUND( (double)corners[0].x + (double)(corners[1].x-corners[0].x)*0.5*(x+1.0) );
1305 pPoint->y=GDI_ROUND( (double)corners[0].y + (double)(corners[1].y-corners[0].y)*0.5*(y+1.0) );
1306 }
1307
1308 /* PATH_NormalizePoint
1309 *
1310 * Normalizes a point with respect to the box whose corners are passed in
1311 * corners. The normalized coordinates are stored in *pX and *pY.
1312 */
1313 VOID
1314 FASTCALL
1315 PATH_NormalizePoint ( FLOAT_POINT corners[],
1316 const FLOAT_POINT *pPoint,
1317 double *pX, double *pY)
1318 {
1319 ASSERT ( corners );
1320 ASSERT ( pPoint );
1321 ASSERT ( pX );
1322 ASSERT ( pY );
1323 *pX=(double)(pPoint->x-corners[0].x)/(double)(corners[1].x-corners[0].x) * 2.0 - 1.0;
1324 *pY=(double)(pPoint->y-corners[0].y)/(double)(corners[1].y-corners[0].y) * 2.0 - 1.0;
1325 }
1326
1327
1328 BOOL FASTCALL PATH_StrokePath(DC *dc, PPATH pPath)
1329 {
1330 BOOL ret = FALSE;
1331 INT i=0;
1332 INT nLinePts, nAlloc;
1333 POINT *pLinePts = NULL;
1334 POINT ptViewportOrg, ptWindowOrg;
1335 SIZE szViewportExt, szWindowExt;
1336 DWORD mapMode, graphicsMode;
1337 XFORM xform;
1338 PDC_ATTR pdcattr = dc->pdcattr;
1339
1340 DPRINT("Enter %s\n", __FUNCTION__);
1341
1342 if (pPath->state != PATH_Closed)
1343 return FALSE;
1344
1345 /* Save the mapping mode info */
1346 mapMode = pdcattr->iMapMode;
1347
1348 DC_vUpdateViewportExt(dc);
1349 szViewportExt = dc->pdcattr->szlViewportExt;
1350 ptViewportOrg = dc->pdcattr->ptlViewportOrg;
1351 szWindowExt = dc->pdcattr->szlWindowExt;
1352 ptWindowOrg = dc->pdcattr->ptlWindowOrg;
1353
1354 MatrixS2XForm(&xform, &dc->dclevel.mxWorldToPage);
1355
1356 /* Set MM_TEXT */
1357 pdcattr->iMapMode = MM_TEXT;
1358 pdcattr->ptlViewportOrg.x = 0;
1359 pdcattr->ptlViewportOrg.y = 0;
1360 pdcattr->ptlWindowOrg.x = 0;
1361 pdcattr->ptlWindowOrg.y = 0;
1362 graphicsMode = pdcattr->iGraphicsMode;
1363 pdcattr->iGraphicsMode = GM_ADVANCED;
1364 IntGdiModifyWorldTransform(dc, &xform, MWT_IDENTITY);
1365 pdcattr->iGraphicsMode = graphicsMode;
1366
1367 /* Allocate enough memory for the worst case without beziers (one PT_MOVETO
1368 * and the rest PT_LINETO with PT_CLOSEFIGURE at the end) plus some buffer
1369 * space in case we get one to keep the number of reallocations small. */
1370 nAlloc = pPath->numEntriesUsed + 1 + 300;
1371 pLinePts = ExAllocatePoolWithTag(PagedPool, nAlloc * sizeof(POINT), TAG_PATH);
1372 if(!pLinePts)
1373 {
1374 DPRINT1("Can't allocate pool!\n");
1375 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1376 goto end;
1377 }
1378 nLinePts = 0;
1379
1380 for(i = 0; i < pPath->numEntriesUsed; i++)
1381 {
1382 if((i == 0 || (pPath->pFlags[i-1] & PT_CLOSEFIGURE))
1383 && (pPath->pFlags[i] != PT_MOVETO))
1384 {
1385 DPRINT1("Expected PT_MOVETO %s, got path flag %d\n",
1386 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1387 (INT)pPath->pFlags[i]);
1388 goto end;
1389 }
1390
1391 switch(pPath->pFlags[i])
1392 {
1393 case PT_MOVETO:
1394 DPRINT("Got PT_MOVETO (%ld, %ld)\n",
1395 pPath->pPoints[i].x, pPath->pPoints[i].y);
1396 if(nLinePts >= 2) IntGdiPolyline(dc, pLinePts, nLinePts);
1397 nLinePts = 0;
1398 pLinePts[nLinePts++] = pPath->pPoints[i];
1399 break;
1400 case PT_LINETO:
1401 case (PT_LINETO | PT_CLOSEFIGURE):
1402 DPRINT("Got PT_LINETO (%ld, %ld)\n",
1403 pPath->pPoints[i].x, pPath->pPoints[i].y);
1404 pLinePts[nLinePts++] = pPath->pPoints[i];
1405 break;
1406 case PT_BEZIERTO:
1407 DPRINT("Got PT_BEZIERTO\n");
1408 if(pPath->pFlags[i+1] != PT_BEZIERTO ||
1409 (pPath->pFlags[i+2] & ~PT_CLOSEFIGURE) != PT_BEZIERTO)
1410 {
1411 DPRINT1("Path didn't contain 3 successive PT_BEZIERTOs\n");
1412 ret = FALSE;
1413 goto end;
1414 }
1415 else
1416 {
1417 INT nBzrPts, nMinAlloc;
1418 POINT *pBzrPts = GDI_Bezier(&pPath->pPoints[i-1], 4, &nBzrPts);
1419 /* Make sure we have allocated enough memory for the lines of
1420 * this bezier and the rest of the path, assuming we won't get
1421 * another one (since we won't reallocate again then). */
1422 nMinAlloc = nLinePts + (pPath->numEntriesUsed - i) + nBzrPts;
1423 if(nAlloc < nMinAlloc)
1424 {
1425 // Reallocate memory
1426
1427 POINT *Realloc = NULL;
1428 nAlloc = nMinAlloc * 2;
1429
1430 Realloc = ExAllocatePoolWithTag(PagedPool,
1431 nAlloc * sizeof(POINT),
1432 TAG_PATH);
1433
1434 if(!Realloc)
1435 {
1436 DPRINT1("Can't allocate pool!\n");
1437 goto end;
1438 }
1439
1440 memcpy(Realloc, pLinePts, nLinePts*sizeof(POINT));
1441 ExFreePoolWithTag(pLinePts, TAG_PATH);
1442 pLinePts = Realloc;
1443 }
1444 memcpy(&pLinePts[nLinePts], &pBzrPts[1], (nBzrPts - 1) * sizeof(POINT));
1445 nLinePts += nBzrPts - 1;
1446 ExFreePoolWithTag(pBzrPts, TAG_BEZIER);
1447 i += 2;
1448 }
1449 break;
1450 default:
1451 DPRINT1("Got path flag %d (not supported)\n", (INT)pPath->pFlags[i]);
1452 goto end;
1453 }
1454
1455 if(pPath->pFlags[i] & PT_CLOSEFIGURE)
1456 {
1457 pLinePts[nLinePts++] = pLinePts[0];
1458 }
1459 }
1460 if(nLinePts >= 2)
1461 IntGdiPolyline(dc, pLinePts, nLinePts);
1462
1463 ret = TRUE;
1464
1465 end:
1466 if(pLinePts) ExFreePoolWithTag(pLinePts, TAG_PATH);
1467
1468 /* Restore the old mapping mode */
1469 pdcattr->iMapMode = mapMode;
1470 pdcattr->szlWindowExt.cx = szWindowExt.cx;
1471 pdcattr->szlWindowExt.cy = szWindowExt.cy;
1472 pdcattr->ptlWindowOrg.x = ptWindowOrg.x;
1473 pdcattr->ptlWindowOrg.y = ptWindowOrg.y;
1474
1475 pdcattr->szlViewportExt.cx = szViewportExt.cx;
1476 pdcattr->szlViewportExt.cy = szViewportExt.cy;
1477 pdcattr->ptlViewportOrg.x = ptViewportOrg.x;
1478 pdcattr->ptlViewportOrg.y = ptViewportOrg.y;
1479
1480 /* Restore the world transform */
1481 XForm2MatrixS(&dc->dclevel.mxWorldToPage, &xform);
1482
1483 /* If we've moved the current point then get its new position
1484 which will be in device (MM_TEXT) co-ords, convert it to
1485 logical co-ords and re-set it. This basically updates
1486 dc->CurPosX|Y so that their values are in the correct mapping
1487 mode.
1488 */
1489 if(i > 0)
1490 {
1491 POINT pt;
1492 IntGetCurrentPositionEx(dc, &pt);
1493 IntDPtoLP(dc, &pt, 1);
1494 IntGdiMoveToEx(dc, pt.x, pt.y, NULL, FALSE);
1495 }
1496 DPRINT("Leave %s, ret=%d\n", __FUNCTION__, ret);
1497 return ret;
1498 }
1499
1500 #define round(x) ((int)((x)>0?(x)+0.5:(x)-0.5))
1501
1502 static
1503 BOOL
1504 FASTCALL
1505 PATH_WidenPath(DC *dc)
1506 {
1507 INT i, j, numStrokes, penWidth, penWidthIn, penWidthOut, size, penStyle;
1508 BOOL ret = FALSE;
1509 PPATH pPath, pNewPath, *pStrokes = NULL, *pOldStrokes, pUpPath, pDownPath;
1510 EXTLOGPEN *elp;
1511 DWORD obj_type, joint, endcap, penType;
1512 PDC_ATTR pdcattr = dc->pdcattr;
1513
1514 pPath = PATH_LockPath( dc->dclevel.hPath );
1515 if (!pPath) return FALSE;
1516
1517 if(pPath->state == PATH_Open)
1518 {
1519 PATH_UnlockPath( pPath );
1520 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1521 return FALSE;
1522 }
1523
1524 PATH_FlattenPath(pPath);
1525
1526 size = IntGdiGetObject( pdcattr->hpen, 0, NULL);
1527 if (!size)
1528 {
1529 PATH_UnlockPath( pPath );
1530 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1531 return FALSE;
1532 }
1533
1534 elp = ExAllocatePoolWithTag(PagedPool, size, TAG_PATH);
1535 (VOID) IntGdiGetObject( pdcattr->hpen, size, elp);
1536
1537 obj_type = GDIOBJ_GetObjectType(pdcattr->hpen);
1538 if(obj_type == GDI_OBJECT_TYPE_PEN)
1539 {
1540 penStyle = ((LOGPEN*)elp)->lopnStyle;
1541 }
1542 else if(obj_type == GDI_OBJECT_TYPE_EXTPEN)
1543 {
1544 penStyle = elp->elpPenStyle;
1545 }
1546 else
1547 {
1548 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1549 ExFreePoolWithTag(elp, TAG_PATH);
1550 PATH_UnlockPath( pPath );
1551 return FALSE;
1552 }
1553
1554 penWidth = elp->elpWidth;
1555 ExFreePoolWithTag(elp, TAG_PATH);
1556
1557 endcap = (PS_ENDCAP_MASK & penStyle);
1558 joint = (PS_JOIN_MASK & penStyle);
1559 penType = (PS_TYPE_MASK & penStyle);
1560
1561 /* The function cannot apply to cosmetic pens */
1562 if(obj_type == GDI_OBJECT_TYPE_EXTPEN && penType == PS_COSMETIC)
1563 {
1564 PATH_UnlockPath( pPath );
1565 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
1566 return FALSE;
1567 }
1568
1569 penWidthIn = penWidth / 2;
1570 penWidthOut = penWidth / 2;
1571 if(penWidthIn + penWidthOut < penWidth)
1572 penWidthOut++;
1573
1574 numStrokes = 0;
1575
1576 for(i = 0, j = 0; i < pPath->numEntriesUsed; i++, j++)
1577 {
1578 POINT point;
1579 if((i == 0 || (pPath->pFlags[i-1] & PT_CLOSEFIGURE)) &&
1580 (pPath->pFlags[i] != PT_MOVETO))
1581 {
1582 DPRINT1("Expected PT_MOVETO %s, got path flag %c\n",
1583 i == 0 ? "as first point" : "after PT_CLOSEFIGURE",
1584 pPath->pFlags[i]);
1585 return FALSE;
1586 }
1587 switch(pPath->pFlags[i])
1588 {
1589 case PT_MOVETO:
1590 if(numStrokes > 0)
1591 {
1592 pStrokes[numStrokes - 1]->state = PATH_Closed;
1593 }
1594 numStrokes++;
1595 j = 0;
1596 if (numStrokes == 1)
1597 pStrokes = ExAllocatePoolWithTag(PagedPool, numStrokes * sizeof(PPATH), TAG_PATH);
1598 else
1599 {
1600 pOldStrokes = pStrokes; // Save old pointer.
1601 pStrokes = ExAllocatePoolWithTag(PagedPool, numStrokes * sizeof(PPATH), TAG_PATH);
1602 if (!pStrokes) return FALSE;
1603 RtlCopyMemory(pStrokes, pOldStrokes, numStrokes * sizeof(PPATH));
1604 ExFreePoolWithTag(pOldStrokes, TAG_PATH); // Free old pointer.
1605 }
1606 if (!pStrokes) return FALSE;
1607 pStrokes[numStrokes - 1] = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1608
1609 PATH_InitGdiPath(pStrokes[numStrokes - 1]);
1610 pStrokes[numStrokes - 1]->state = PATH_Open;
1611 case PT_LINETO:
1612 case (PT_LINETO | PT_CLOSEFIGURE):
1613 point.x = pPath->pPoints[i].x;
1614 point.y = pPath->pPoints[i].y;
1615 PATH_AddEntry(pStrokes[numStrokes - 1], &point, pPath->pFlags[i]);
1616 break;
1617 case PT_BEZIERTO:
1618 /* should never happen because of the FlattenPath call */
1619 DPRINT1("Should never happen\n");
1620 break;
1621 default:
1622 DPRINT1("Got path flag %c\n", pPath->pFlags[i]);
1623 return FALSE;
1624 }
1625 }
1626
1627 pNewPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1628 PATH_InitGdiPath(pNewPath);
1629 pNewPath->state = PATH_Open;
1630
1631 for(i = 0; i < numStrokes; i++)
1632 {
1633 pUpPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1634 PATH_InitGdiPath(pUpPath);
1635 pUpPath->state = PATH_Open;
1636 pDownPath = ExAllocatePoolWithTag(PagedPool, sizeof(PATH), TAG_PATH);
1637 PATH_InitGdiPath(pDownPath);
1638 pDownPath->state = PATH_Open;
1639
1640 for(j = 0; j < pStrokes[i]->numEntriesUsed; j++)
1641 {
1642 /* Beginning or end of the path if not closed */
1643 if((!(pStrokes[i]->pFlags[pStrokes[i]->numEntriesUsed - 1] & PT_CLOSEFIGURE)) && (j == 0 || j == pStrokes[i]->numEntriesUsed - 1) )
1644 {
1645 /* Compute segment angle */
1646 double xo, yo, xa, ya, theta;
1647 POINT pt;
1648 FLOAT_POINT corners[2];
1649 if(j == 0)
1650 {
1651 xo = pStrokes[i]->pPoints[j].x;
1652 yo = pStrokes[i]->pPoints[j].y;
1653 xa = pStrokes[i]->pPoints[1].x;
1654 ya = pStrokes[i]->pPoints[1].y;
1655 }
1656 else
1657 {
1658 xa = pStrokes[i]->pPoints[j - 1].x;
1659 ya = pStrokes[i]->pPoints[j - 1].y;
1660 xo = pStrokes[i]->pPoints[j].x;
1661 yo = pStrokes[i]->pPoints[j].y;
1662 }
1663 theta = atan2( ya - yo, xa - xo );
1664 switch(endcap)
1665 {
1666 case PS_ENDCAP_SQUARE :
1667 pt.x = xo + round(sqrt(2) * penWidthOut * cos(M_PI_4 + theta));
1668 pt.y = yo + round(sqrt(2) * penWidthOut * sin(M_PI_4 + theta));
1669 PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO) );
1670 pt.x = xo + round(sqrt(2) * penWidthIn * cos(- M_PI_4 + theta));
1671 pt.y = yo + round(sqrt(2) * penWidthIn * sin(- M_PI_4 + theta));
1672 PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1673 break;
1674 case PS_ENDCAP_FLAT :
1675 pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1676 pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1677 PATH_AddEntry(pUpPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1678 pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1679 pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1680 PATH_AddEntry(pUpPath, &pt, PT_LINETO);
1681 break;
1682 case PS_ENDCAP_ROUND :
1683 default :
1684 corners[0].x = xo - penWidthIn;
1685 corners[0].y = yo - penWidthIn;
1686 corners[1].x = xo + penWidthOut;
1687 corners[1].y = yo + penWidthOut;
1688 PATH_DoArcPart(pUpPath ,corners, theta + M_PI_2 , theta + 3 * M_PI_4, (j == 0 ? PT_MOVETO : FALSE));
1689 PATH_DoArcPart(pUpPath ,corners, theta + 3 * M_PI_4 , theta + M_PI, FALSE);
1690 PATH_DoArcPart(pUpPath ,corners, theta + M_PI, theta + 5 * M_PI_4, FALSE);
1691 PATH_DoArcPart(pUpPath ,corners, theta + 5 * M_PI_4 , theta + 3 * M_PI_2, FALSE);
1692 break;
1693 }
1694 }
1695 /* Corpse of the path */
1696 else
1697 {
1698 /* Compute angle */
1699 INT previous, next;
1700 double xa, ya, xb, yb, xo, yo;
1701 double alpha, theta, miterWidth;
1702 DWORD _joint = joint;
1703 POINT pt;
1704 PPATH pInsidePath, pOutsidePath;
1705 if(j > 0 && j < pStrokes[i]->numEntriesUsed - 1)
1706 {
1707 previous = j - 1;
1708 next = j + 1;
1709 }
1710 else if (j == 0)
1711 {
1712 previous = pStrokes[i]->numEntriesUsed - 1;
1713 next = j + 1;
1714 }
1715 else
1716 {
1717 previous = j - 1;
1718 next = 0;
1719 }
1720 xo = pStrokes[i]->pPoints[j].x;
1721 yo = pStrokes[i]->pPoints[j].y;
1722 xa = pStrokes[i]->pPoints[previous].x;
1723 ya = pStrokes[i]->pPoints[previous].y;
1724 xb = pStrokes[i]->pPoints[next].x;
1725 yb = pStrokes[i]->pPoints[next].y;
1726 theta = atan2( yo - ya, xo - xa );
1727 alpha = atan2( yb - yo, xb - xo ) - theta;
1728 if (alpha > 0) alpha -= M_PI;
1729 else alpha += M_PI;
1730 if(_joint == PS_JOIN_MITER && dc->dclevel.laPath.eMiterLimit < fabs(1 / sin(alpha/2)))
1731 {
1732 _joint = PS_JOIN_BEVEL;
1733 }
1734 if(alpha > 0)
1735 {
1736 pInsidePath = pUpPath;
1737 pOutsidePath = pDownPath;
1738 }
1739 else if(alpha < 0)
1740 {
1741 pInsidePath = pDownPath;
1742 pOutsidePath = pUpPath;
1743 }
1744 else
1745 {
1746 continue;
1747 }
1748 /* Inside angle points */
1749 if(alpha > 0)
1750 {
1751 pt.x = xo - round( penWidthIn * cos(theta + M_PI_2) );
1752 pt.y = yo - round( penWidthIn * sin(theta + M_PI_2) );
1753 }
1754 else
1755 {
1756 pt.x = xo + round( penWidthIn * cos(theta + M_PI_2) );
1757 pt.y = yo + round( penWidthIn * sin(theta + M_PI_2) );
1758 }
1759 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1760 if(alpha > 0)
1761 {
1762 pt.x = xo + round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1763 pt.y = yo + round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1764 }
1765 else
1766 {
1767 pt.x = xo - round( penWidthIn * cos(M_PI_2 + alpha + theta) );
1768 pt.y = yo - round( penWidthIn * sin(M_PI_2 + alpha + theta) );
1769 }
1770 PATH_AddEntry(pInsidePath, &pt, PT_LINETO);
1771 /* Outside angle point */
1772 switch(_joint)
1773 {
1774 case PS_JOIN_MITER :
1775 miterWidth = fabs(penWidthOut / cos(M_PI_2 - fabs(alpha) / 2));
1776 pt.x = xo + round( miterWidth * cos(theta + alpha / 2) );
1777 pt.y = yo + round( miterWidth * sin(theta + alpha / 2) );
1778 PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1779 break;
1780 case PS_JOIN_BEVEL :
1781 if(alpha > 0)
1782 {
1783 pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1784 pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1785 }
1786 else
1787 {
1788 pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1789 pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1790 }
1791 PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1792 if(alpha > 0)
1793 {
1794 pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1795 pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1796 }
1797 else
1798 {
1799 pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1800 pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1801 }
1802 PATH_AddEntry(pOutsidePath, &pt, PT_LINETO);
1803 break;
1804 case PS_JOIN_ROUND :
1805 default :
1806 if(alpha > 0)
1807 {
1808 pt.x = xo + round( penWidthOut * cos(theta + M_PI_2) );
1809 pt.y = yo + round( penWidthOut * sin(theta + M_PI_2) );
1810 }
1811 else
1812 {
1813 pt.x = xo - round( penWidthOut * cos(theta + M_PI_2) );
1814 pt.y = yo - round( penWidthOut * sin(theta + M_PI_2) );
1815 }
1816 PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1817 pt.x = xo + round( penWidthOut * cos(theta + alpha / 2) );
1818 pt.y = yo + round( penWidthOut * sin(theta + alpha / 2) );
1819 PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1820 if(alpha > 0)
1821 {
1822 pt.x = xo - round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1823 pt.y = yo - round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1824 }
1825 else
1826 {
1827 pt.x = xo + round( penWidthOut * cos(M_PI_2 + alpha + theta) );
1828 pt.y = yo + round( penWidthOut * sin(M_PI_2 + alpha + theta) );
1829 }
1830 PATH_AddEntry(pOutsidePath, &pt, PT_BEZIERTO);
1831 break;
1832 }
1833 }
1834 }
1835 for(j = 0; j < pUpPath->numEntriesUsed; j++)
1836 {
1837 POINT pt;
1838 pt.x = pUpPath->pPoints[j].x;
1839 pt.y = pUpPath->pPoints[j].y;
1840 PATH_AddEntry(pNewPath, &pt, (j == 0 ? PT_MOVETO : PT_LINETO));
1841 }
1842 for(j = 0; j < pDownPath->numEntriesUsed; j++)
1843 {
1844 POINT pt;
1845 pt.x = pDownPath->pPoints[pDownPath->numEntriesUsed - j - 1].x;
1846 pt.y = pDownPath->pPoints[pDownPath->numEntriesUsed - j - 1].y;
1847 PATH_AddEntry(pNewPath, &pt, ( (j == 0 && (pStrokes[i]->pFlags[pStrokes[i]->numEntriesUsed - 1] & PT_CLOSEFIGURE)) ? PT_MOVETO : PT_LINETO));
1848 }
1849
1850 PATH_DestroyGdiPath(pStrokes[i]);
1851 ExFreePoolWithTag(pStrokes[i], TAG_PATH);
1852 PATH_DestroyGdiPath(pUpPath);
1853 ExFreePoolWithTag(pUpPath, TAG_PATH);
1854 PATH_DestroyGdiPath(pDownPath);
1855 ExFreePoolWithTag(pDownPath, TAG_PATH);
1856 }
1857 ExFreePoolWithTag(pStrokes, TAG_PATH);
1858
1859 pNewPath->state = PATH_Closed;
1860 if (!(ret = PATH_AssignGdiPath(pPath, pNewPath)))
1861 DPRINT1("Assign path failed\n");
1862 PATH_DestroyGdiPath(pNewPath);
1863 ExFreePoolWithTag(pNewPath, TAG_PATH);
1864 return ret;
1865 }
1866
1867 static inline INT int_from_fixed(FIXED f)
1868 {
1869 return (f.fract >= 0x8000) ? (f.value + 1) : f.value;
1870 }
1871
1872 /**********************************************************************
1873 * PATH_BezierTo
1874 *
1875 * internally used by PATH_add_outline
1876 */
1877 static
1878 VOID
1879 FASTCALL
1880 PATH_BezierTo(PPATH pPath, POINT *lppt, INT n)
1881 {
1882 if (n < 2) return;
1883
1884 if (n == 2)
1885 {
1886 PATH_AddEntry(pPath, &lppt[1], PT_LINETO);
1887 }
1888 else if (n == 3)
1889 {
1890 PATH_AddEntry(pPath, &lppt[0], PT_BEZIERTO);
1891 PATH_AddEntry(pPath, &lppt[1], PT_BEZIERTO);
1892 PATH_AddEntry(pPath, &lppt[2], PT_BEZIERTO);
1893 }
1894 else
1895 {
1896 POINT pt[3];
1897 INT i = 0;
1898
1899 pt[2] = lppt[0];
1900 n--;
1901
1902 while (n > 2)
1903 {
1904 pt[0] = pt[2];
1905 pt[1] = lppt[i+1];
1906 pt[2].x = (lppt[i+2].x + lppt[i+1].x) / 2;
1907 pt[2].y = (lppt[i+2].y + lppt[i+1].y) / 2;
1908 PATH_BezierTo(pPath, pt, 3);
1909 n--;
1910 i++;
1911 }
1912
1913 pt[0] = pt[2];
1914 pt[1] = lppt[i+1];
1915 pt[2] = lppt[i+2];
1916 PATH_BezierTo(pPath, pt, 3);
1917 }
1918 }
1919
1920 static
1921 BOOL
1922 FASTCALL
1923 PATH_add_outline(PDC dc, INT x, INT y, TTPOLYGONHEADER *header, DWORD size)
1924 {
1925 PPATH pPath;
1926 TTPOLYGONHEADER *start;
1927 POINT pt;
1928
1929 start = header;
1930
1931 pPath = PATH_LockPath(dc->dclevel.hPath);
1932 {
1933 return FALSE;
1934 }
1935
1936 while ((char *)header < (char *)start + size)
1937 {
1938 TTPOLYCURVE *curve;
1939
1940 if (header->dwType != TT_POLYGON_TYPE)
1941 {
1942 DPRINT1("Unknown header type %d\n", header->dwType);
1943 return FALSE;
1944 }
1945
1946 pt.x = x + int_from_fixed(header->pfxStart.x);
1947 pt.y = y - int_from_fixed(header->pfxStart.y);
1948 IntLPtoDP(dc, &pt, 1);
1949 PATH_AddEntry(pPath, &pt, PT_MOVETO);
1950
1951 curve = (TTPOLYCURVE *)(header + 1);
1952
1953 while ((char *)curve < (char *)header + header->cb)
1954 {
1955 /*DPRINT1("curve->wType %d\n", curve->wType);*/
1956
1957 switch(curve->wType)
1958 {
1959 case TT_PRIM_LINE:
1960 {
1961 WORD i;
1962
1963 for (i = 0; i < curve->cpfx; i++)
1964 {
1965 pt.x = x + int_from_fixed(curve->apfx[i].x);
1966 pt.y = y - int_from_fixed(curve->apfx[i].y);
1967 IntLPtoDP(dc, &pt, 1);
1968 PATH_AddEntry(pPath, &pt, PT_LINETO);
1969 }
1970 break;
1971 }
1972
1973 case TT_PRIM_QSPLINE:
1974 case TT_PRIM_CSPLINE:
1975 {
1976 WORD i;
1977 POINTFX ptfx;
1978 POINT *pts = ExAllocatePoolWithTag(PagedPool, (curve->cpfx + 1) * sizeof(POINT), TAG_PATH);
1979
1980 if (!pts) return FALSE;
1981
1982 ptfx = *(POINTFX *)((char *)curve - sizeof(POINTFX));
1983
1984 pts[0].x = x + int_from_fixed(ptfx.x);
1985 pts[0].y = y - int_from_fixed(ptfx.y);
1986 IntLPtoDP(dc, &pts[0], 1);
1987
1988 for (i = 0; i < curve->cpfx; i++)
1989 {
1990 pts[i + 1].x = x + int_from_fixed(curve->apfx[i].x);
1991 pts[i + 1].y = y - int_from_fixed(curve->apfx[i].y);
1992 IntLPtoDP(dc, &pts[i + 1], 1);
1993 }
1994
1995 PATH_BezierTo(pPath, pts, curve->cpfx + 1);
1996
1997 ExFreePoolWithTag(pts, TAG_PATH);
1998 break;
1999 }
2000
2001 default:
2002 DPRINT1("Unknown curve type %04x\n", curve->wType);
2003 return FALSE;
2004 }
2005
2006 curve = (TTPOLYCURVE *)&curve->apfx[curve->cpfx];
2007 }
2008 header = (TTPOLYGONHEADER *)((char *)header + header->cb);
2009 }
2010
2011 IntGdiCloseFigure( pPath );
2012 PATH_UnlockPath( pPath );
2013 return TRUE;
2014 }
2015
2016 /**********************************************************************
2017 * PATH_ExtTextOut
2018 */
2019 BOOL
2020 FASTCALL
2021 PATH_ExtTextOut(PDC dc, INT x, INT y, UINT flags, const RECTL *lprc,
2022 LPCWSTR str, UINT count, const INT *dx)
2023 {
2024 unsigned int idx;
2025 double cosEsc, sinEsc;
2026 PDC_ATTR pdcattr;
2027 PTEXTOBJ TextObj;
2028 LOGFONTW lf;
2029 POINTL org;
2030 INT offset = 0, xoff = 0, yoff = 0;
2031
2032 if (!count) return TRUE;
2033
2034 pdcattr = dc->pdcattr;
2035
2036 TextObj = RealizeFontInit( pdcattr->hlfntNew);
2037 if ( !TextObj ) return FALSE;
2038
2039 FontGetObject( TextObj, sizeof(lf), &lf);
2040
2041 if (lf.lfEscapement != 0)
2042 {
2043 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
2044 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
2045 } else
2046 {
2047 cosEsc = 1;
2048 sinEsc = 0;
2049 }
2050
2051 IntGdiGetDCOrg(dc, &org);
2052
2053 for (idx = 0; idx < count; idx++)
2054 {
2055 GLYPHMETRICS gm;
2056 DWORD dwSize;
2057 void *outline;
2058
2059 dwSize = ftGdiGetGlyphOutline( dc,
2060 str[idx],
2061 GGO_GLYPH_INDEX | GGO_NATIVE,
2062 &gm,
2063 0,
2064 NULL,
2065 NULL,
2066 TRUE);
2067 if (!dwSize) return FALSE;
2068
2069 outline = ExAllocatePoolWithTag(PagedPool, dwSize, TAG_PATH);
2070 if (!outline) return FALSE;
2071
2072 ftGdiGetGlyphOutline( dc,
2073 str[idx],
2074 GGO_GLYPH_INDEX | GGO_NATIVE,
2075 &gm,
2076 dwSize,
2077 outline,
2078 NULL,
2079 TRUE);
2080
2081 PATH_add_outline(dc, org.x + x + xoff, org.x + y + yoff, outline, dwSize);
2082
2083 ExFreePoolWithTag(outline, TAG_PATH);
2084
2085 if (dx)
2086 {
2087 offset += dx[idx];
2088 xoff = offset * cosEsc;
2089 yoff = offset * -sinEsc;
2090 }
2091 else
2092 {
2093 xoff += gm.gmCellIncX;
2094 yoff += gm.gmCellIncY;
2095 }
2096 }
2097 return TRUE;
2098 }
2099
2100
2101 /***********************************************************************
2102 * Exported functions
2103 */
2104
2105 BOOL
2106 APIENTRY
2107 NtGdiAbortPath(HDC hDC)
2108 {
2109 PPATH pPath;
2110 PDC dc = DC_LockDc ( hDC );
2111 if ( !dc )
2112 {
2113 SetLastWin32Error(ERROR_INVALID_HANDLE);
2114 return FALSE;
2115 }
2116
2117 pPath = PATH_LockPath(dc->dclevel.hPath);
2118 {
2119 DC_UnlockDc(dc);
2120 return FALSE;
2121 }
2122
2123 PATH_EmptyPath(pPath);
2124
2125 PATH_UnlockPath(pPath);
2126 DC_UnlockDc ( dc );
2127 return TRUE;
2128 }
2129
2130 BOOL
2131 APIENTRY
2132 NtGdiBeginPath( HDC hDC )
2133 {
2134 PPATH pPath;
2135 PDC dc;
2136
2137 dc = DC_LockDc ( hDC );
2138 if ( !dc )
2139 {
2140 SetLastWin32Error(ERROR_INVALID_HANDLE);
2141 return FALSE;
2142 }
2143
2144 /* If path is already open, do nothing. Check if not Save DC state */
2145 if ((dc->dclevel.flPath & DCPATH_ACTIVE) && !(dc->dclevel.flPath & DCPATH_SAVE))
2146 {
2147 DC_UnlockDc ( dc );
2148 return TRUE;
2149 }
2150
2151 if ( dc->dclevel.hPath )
2152 {
2153 DPRINT1("BeginPath 1 0x%x\n", dc->dclevel.hPath);
2154 if ( !(dc->dclevel.flPath & DCPATH_SAVE) )
2155 { // Remove previous handle.
2156 if (!PATH_Delete(dc->dclevel.hPath))
2157 {
2158 DC_UnlockDc ( dc );
2159 return FALSE;
2160 }
2161 }
2162 else
2163 { // Clear flags and Handle.
2164 dc->dclevel.flPath &= ~(DCPATH_SAVE|DCPATH_ACTIVE);
2165 dc->dclevel.hPath = NULL;
2166 }
2167 }
2168 pPath = PATH_AllocPathWithHandle();
2169 if (!pPath)
2170 {
2171 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
2172 return FALSE;
2173 }
2174 dc->dclevel.flPath |= DCPATH_ACTIVE; // Set active ASAP!
2175
2176 dc->dclevel.hPath = pPath->BaseObject.hHmgr;
2177
2178 DPRINT1("BeginPath 2 h 0x%x p 0x%x\n", dc->dclevel.hPath, pPath);
2179 // Path handles are shared. Also due to recursion with in the same thread.
2180 GDIOBJ_UnlockObjByPtr((POBJ)pPath); // Unlock
2181 pPath = PATH_LockPath(dc->dclevel.hPath); // Share Lock.
2182
2183 /* Make sure that path is empty */
2184 PATH_EmptyPath( pPath );
2185
2186 /* Initialize variables for new path */
2187 pPath->newStroke = TRUE;
2188 pPath->state = PATH_Open;
2189
2190 PATH_UnlockPath(pPath);
2191 DC_UnlockDc ( dc );
2192 return TRUE;
2193 }
2194
2195 BOOL
2196 APIENTRY
2197 NtGdiCloseFigure(HDC hDC)
2198 {
2199 BOOL Ret = FALSE; // default to failure
2200 PDC pDc;
2201 PPATH pPath;
2202
2203 DPRINT("Enter %s\n", __FUNCTION__);
2204
2205 pDc = DC_LockDc(hDC);
2206 if (!pDc)
2207 {
2208 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2209 return FALSE;
2210 }
2211 pPath = PATH_LockPath( pDc->dclevel.hPath );
2212 if (!pPath)
2213 {
2214 DC_UnlockDc(pDc);
2215 return FALSE;
2216 }
2217
2218 if (pPath->state==PATH_Open)
2219 {
2220 IntGdiCloseFigure(pPath);
2221 Ret = TRUE;
2222 }
2223 else
2224 {
2225 // FIXME: check if lasterror is set correctly
2226 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2227 }
2228
2229 PATH_UnlockPath( pPath );
2230 DC_UnlockDc(pDc);
2231 return Ret;
2232 }
2233
2234 BOOL
2235 APIENTRY
2236 NtGdiEndPath(HDC hDC)
2237 {
2238 BOOL ret = TRUE;
2239 PPATH pPath;
2240 PDC dc = DC_LockDc ( hDC );
2241
2242 if ( !dc )
2243 {
2244 SetLastWin32Error(ERROR_INVALID_HANDLE);
2245 return FALSE;
2246 }
2247
2248 pPath = PATH_LockPath( dc->dclevel.hPath );
2249 if (!pPath)
2250 {
2251 DC_UnlockDc ( dc );
2252 return FALSE;
2253 }
2254 /* Check that path is currently being constructed */
2255 if ( (pPath->state != PATH_Open) || !(dc->dclevel.flPath & DCPATH_ACTIVE) )
2256 {
2257 DPRINT1("EndPath ERROR! 0x%x\n", dc->dclevel.hPath);
2258 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2259 ret = FALSE;
2260 }
2261 /* Set flag to indicate that path is finished */
2262 else
2263 {
2264 DPRINT1("EndPath 0x%x\n", dc->dclevel.hPath);
2265 pPath->state = PATH_Closed;
2266 dc->dclevel.flPath &= ~DCPATH_ACTIVE;
2267 }
2268 PATH_UnlockPath( pPath );
2269 DC_UnlockDc ( dc );
2270 return ret;
2271 }
2272
2273 BOOL
2274 APIENTRY
2275 NtGdiFillPath(HDC hDC)
2276 {
2277 BOOL ret = FALSE;
2278 PPATH pPath;
2279 PDC_ATTR pdcattr;
2280 PDC dc = DC_LockDc ( hDC );
2281
2282 if ( !dc )
2283 {
2284 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2285 return FALSE;
2286 }
2287 pPath = PATH_LockPath( dc->dclevel.hPath );
2288 if (!pPath)
2289 {
2290 DC_UnlockDc ( dc );
2291 return FALSE;
2292 }
2293
2294 DC_vPrepareDCsForBlit(dc, dc->rosdc.CombinedClip->rclBounds,
2295 NULL, dc->rosdc.CombinedClip->rclBounds);
2296
2297 pdcattr = dc->pdcattr;
2298
2299 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2300 DC_vUpdateLineBrush(dc);
2301
2302 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
2303 DC_vUpdateFillBrush(dc);
2304
2305 ret = PATH_FillPath( dc, pPath );
2306 if ( ret )
2307 {
2308 /* FIXME: Should the path be emptied even if conversion
2309 failed? */
2310 PATH_EmptyPath( pPath );
2311 }
2312
2313 PATH_UnlockPath( pPath );
2314 DC_vFinishBlit(dc, NULL);
2315 DC_UnlockDc ( dc );
2316 return ret;
2317 }
2318
2319 BOOL
2320 APIENTRY
2321 NtGdiFlattenPath(HDC hDC)
2322 {
2323 BOOL Ret = FALSE;
2324 DC *pDc;
2325 PPATH pPath;
2326
2327 DPRINT("Enter %s\n", __FUNCTION__);
2328
2329 pDc = DC_LockDc(hDC);
2330 if (!pDc)
2331 {
2332 SetLastWin32Error(ERROR_INVALID_HANDLE);
2333 return FALSE;
2334 }
2335
2336 pPath = PATH_LockPath( pDc->dclevel.hPath );
2337 if (!pPath)
2338 {
2339 DC_UnlockDc ( pDc );
2340 return FALSE;
2341 }
2342 if (pPath->state == PATH_Open)
2343 Ret = PATH_FlattenPath(pPath);
2344
2345 PATH_UnlockPath( pPath );
2346 DC_UnlockDc(pDc);
2347 return Ret;
2348 }
2349
2350
2351 BOOL
2352 APIENTRY
2353 NtGdiGetMiterLimit(
2354 IN HDC hdc,
2355 OUT PDWORD pdwOut)
2356 {
2357 DC *pDc;
2358 gxf_long worker;
2359 NTSTATUS Status = STATUS_SUCCESS;
2360
2361 if (!(pDc = DC_LockDc(hdc)))
2362 {
2363 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2364 return FALSE;
2365 }
2366
2367 worker.f = pDc->dclevel.laPath.eMiterLimit;
2368
2369 if (pdwOut)
2370 {
2371 _SEH2_TRY
2372 {
2373 ProbeForWrite(pdwOut,
2374 sizeof(DWORD),
2375 1);
2376 *pdwOut = worker.l;
2377 }
2378 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2379 {
2380 Status = _SEH2_GetExceptionCode();
2381 }
2382 _SEH2_END;
2383 if (!NT_SUCCESS(Status))
2384 {
2385 SetLastNtError(Status);
2386 DC_UnlockDc(pDc);
2387 return FALSE;
2388 }
2389 }
2390
2391 DC_UnlockDc(pDc);
2392 return TRUE;
2393
2394 }
2395
2396 INT
2397 APIENTRY
2398 NtGdiGetPath(
2399 HDC hDC,
2400 LPPOINT Points,
2401 LPBYTE Types,
2402 INT nSize)
2403 {
2404 INT ret = -1;
2405 PPATH pPath;
2406
2407 DC *dc = DC_LockDc(hDC);
2408 if (!dc)
2409 {
2410 DPRINT1("Can't lock dc!\n");
2411 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2412 return -1;
2413 }
2414
2415 pPath = PATH_LockPath( dc->dclevel.hPath );
2416 if (!pPath)
2417 {
2418 DC_UnlockDc ( dc );
2419 return -1;
2420 }
2421
2422 if (pPath->state != PATH_Closed)
2423 {
2424 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2425 goto done;
2426 }
2427
2428 if (nSize==0)
2429 {
2430 ret = pPath->numEntriesUsed;
2431 }
2432 else if(nSize<pPath->numEntriesUsed)
2433 {
2434 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2435 goto done;
2436 }
2437 else
2438 {
2439 _SEH2_TRY
2440 {
2441 memcpy(Points, pPath->pPoints, sizeof(POINT)*pPath->numEntriesUsed);
2442 memcpy(Types, pPath->pFlags, sizeof(BYTE)*pPath->numEntriesUsed);
2443
2444 /* Convert the points to logical coordinates */
2445 IntDPtoLP(dc, Points, pPath->numEntriesUsed);
2446
2447 ret = pPath->numEntriesUsed;
2448 }
2449 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2450 {
2451 SetLastNtError(_SEH2_GetExceptionCode());
2452 }
2453 _SEH2_END
2454 }
2455
2456 done:
2457 PATH_UnlockPath( pPath );
2458 DC_UnlockDc(dc);
2459 return ret;
2460 }
2461
2462 HRGN
2463 APIENTRY
2464 NtGdiPathToRegion(HDC hDC)
2465 {
2466 PPATH pPath;
2467 HRGN hrgnRval = 0;
2468 DC *pDc;
2469 PDC_ATTR pdcattr;
2470
2471 DPRINT("Enter %s\n", __FUNCTION__);
2472
2473 pDc = DC_LockDc(hDC);
2474 if (!pDc)
2475 {
2476 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2477 return NULL;
2478 }
2479
2480 pdcattr = pDc->pdcattr;
2481
2482 pPath = PATH_LockPath( pDc->dclevel.hPath );
2483 if (!pPath)
2484 {
2485 DC_UnlockDc ( pDc );
2486 return NULL;
2487 }
2488
2489 if (pPath->state!=PATH_Closed)
2490 {
2491 //FIXME: check that setlasterror is being called correctly
2492 SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
2493 }
2494 else
2495 {
2496 /* FIXME: Should we empty the path even if conversion failed? */
2497 if(PATH_PathToRegion(pPath, pdcattr->jFillMode, &hrgnRval))
2498 PATH_EmptyPath(pPath);
2499 }
2500
2501 PATH_UnlockPath( pPath );
2502 DC_UnlockDc(pDc);
2503 return hrgnRval;
2504 }
2505
2506 BOOL
2507 APIENTRY
2508 NtGdiSetMiterLimit(
2509 IN HDC hdc,
2510 IN DWORD dwNew,
2511 IN OUT OPTIONAL PDWORD pdwOut)
2512 {
2513 DC *pDc;
2514 gxf_long worker, worker1;
2515 NTSTATUS Status = STATUS_SUCCESS;
2516
2517 if (!(pDc = DC_LockDc(hdc)))
2518 {
2519 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2520 return FALSE;
2521 }
2522
2523 worker.l = dwNew;
2524 worker1.f = pDc->dclevel.laPath.eMiterLimit;
2525 pDc->dclevel.laPath.eMiterLimit = worker.f;
2526
2527 if (pdwOut)
2528 {
2529 _SEH2_TRY
2530 {
2531 ProbeForWrite(pdwOut,
2532 sizeof(DWORD),
2533 1);
2534 *pdwOut = worker1.l;
2535 }
2536 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2537 {
2538 Status = _SEH2_GetExceptionCode();
2539 }
2540 _SEH2_END;
2541 if (!NT_SUCCESS(Status))
2542 {
2543 SetLastNtError(Status);
2544 DC_UnlockDc(pDc);
2545 return FALSE;
2546 }
2547 }
2548
2549 DC_UnlockDc(pDc);
2550 return TRUE;
2551 }
2552
2553 BOOL
2554 APIENTRY
2555 NtGdiStrokeAndFillPath(HDC hDC)
2556 {
2557 DC *pDc;
2558 PDC_ATTR pdcattr;
2559 PPATH pPath;
2560 BOOL bRet = FALSE;
2561
2562 DPRINT1("Enter %s\n", __FUNCTION__);
2563
2564 if (!(pDc = DC_LockDc(hDC)))
2565 {
2566 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2567 return FALSE;
2568 }
2569 pPath = PATH_LockPath( pDc->dclevel.hPath );
2570 if (!pPath)
2571 {
2572 DC_UnlockDc ( pDc );
2573 return FALSE;
2574 }
2575
2576 DC_vPrepareDCsForBlit(pDc, pDc->rosdc.CombinedClip->rclBounds,
2577 NULL, pDc->rosdc.CombinedClip->rclBounds);
2578
2579 pdcattr = pDc->pdcattr;
2580
2581 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
2582 DC_vUpdateFillBrush(pDc);
2583
2584 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2585 DC_vUpdateLineBrush(pDc);
2586
2587 bRet = PATH_FillPath(pDc, pPath);
2588 if (bRet) bRet = PATH_StrokePath(pDc, pPath);
2589 if (bRet) PATH_EmptyPath(pPath);
2590
2591 PATH_UnlockPath( pPath );
2592 DC_vFinishBlit(pDc, NULL);
2593 DC_UnlockDc(pDc);
2594 return bRet;
2595 }
2596
2597 BOOL
2598 APIENTRY
2599 NtGdiStrokePath(HDC hDC)
2600 {
2601 DC *pDc;
2602 PDC_ATTR pdcattr;
2603 PPATH pPath;
2604 BOOL bRet = FALSE;
2605
2606 DPRINT("Enter %s\n", __FUNCTION__);
2607
2608 if (!(pDc = DC_LockDc(hDC)))
2609 {
2610 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2611 return FALSE;
2612 }
2613 pPath = PATH_LockPath( pDc->dclevel.hPath );
2614 if (!pPath)
2615 {
2616 DC_UnlockDc ( pDc );
2617 return FALSE;
2618 }
2619
2620 DC_vPrepareDCsForBlit(pDc, pDc->rosdc.CombinedClip->rclBounds,
2621 NULL, pDc->rosdc.CombinedClip->rclBounds);
2622
2623 pdcattr = pDc->pdcattr;
2624
2625 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
2626 DC_vUpdateLineBrush(pDc);
2627
2628 bRet = PATH_StrokePath(pDc, pPath);
2629
2630 DC_vFinishBlit(pDc, NULL);
2631 PATH_EmptyPath(pPath);
2632
2633 PATH_UnlockPath( pPath );
2634 DC_UnlockDc(pDc);
2635 return bRet;
2636 }
2637
2638 BOOL
2639 APIENTRY
2640 NtGdiWidenPath(HDC hDC)
2641 {
2642 BOOL Ret;
2643 PDC pdc = DC_LockDc ( hDC );
2644 if ( !pdc )
2645 {
2646 SetLastWin32Error(ERROR_INVALID_PARAMETER);
2647 return FALSE;
2648 }
2649 Ret = PATH_WidenPath(pdc);
2650 DC_UnlockDc ( pdc );
2651 return Ret;
2652 }
2653
2654 /* EOF */